xref: /cts/tests/location/location_gnss/src/android/location/cts/gnss/asn1/supl2/supl_start/PosTechnology.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, 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();
  }
}