tests/location/location_gnss/src/android/location/cts/gnss/asn1/supl2/supl_response/SETAuthKey.java - platform/cts - Git at Google

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