package generated.javacard.mondex.purse;

public class Store {

	public final static short LENGTHOFSTRING = 20;
	public final static short LENGTHOFSECRET = 8;
	public final static short LENGTHOFNONCE = 8;
	public final static short MAXENCRYPTLENGTHSYMM = 64;
	public final static short ValMaxCountForPurse = 1;
	public final static short EncDataSymmMaxCountForPurse = 1;
	public final static short ReqMaxCountForPurse = 1;
	public final static short ResGetDataMaxCountForPurse = 1;
	public final static short StartToMaxCountForPurse = 1;
	public final static short AckMaxCountForPurse = 1;
	public final static short SymmkeyMaxCountForPurse = 0;
	public final static short ResGetBalanceMaxCountForPurse = 1;
	public final static short MsgcontentMaxCountForPurse = 2;
	public final static short GetBalanceMaxCountForPurse = 1;
	public final static short GetDataMaxCountForPurse = 1;
	public final static short StartFromMaxCountForPurse = 1;

	// ************************************************
	private static EncDataSymm[] EncDataSymmArray;
	private static byte EncDataSymmCount = 0;
	private static void initEncDataSymm() {
		EncDataSymmArray = new EncDataSymm[EncDataSymmMaxCountForPurse];
		for (short i = 0; i < EncDataSymmArray.length; i++)
			EncDataSymmArray[i] = new EncDataSymm();
	}
	public static EncDataSymm newEncDataSymm() {
		return EncDataSymmArray[EncDataSymmCount++];
	}

	// ************************************************
	private static Symmkey[] SymmkeyArray;
	private static byte SymmkeyCount = 0;
	private static void initSymmkey() {
		SymmkeyArray = new Symmkey[SymmkeyMaxCountForPurse];
		for (short i = 0; i < SymmkeyArray.length; i++)
			SymmkeyArray[i] = new Symmkey();
	}
	public static Symmkey newSymmkey() {
		return SymmkeyArray[SymmkeyCount++];
	}

	// ************************************************
	private static ResGetBalance[] ResGetBalanceArray;
	private static byte ResGetBalanceCount = 0;
	private static void initResGetBalance() {
		ResGetBalanceArray = new ResGetBalance[ResGetBalanceMaxCountForPurse];
		for (short i = 0; i < ResGetBalanceArray.length; i++)
			ResGetBalanceArray[i] = new ResGetBalance();
	}
	public static ResGetBalance newResGetBalance() {
		return ResGetBalanceArray[ResGetBalanceCount++];
	}

	// ************************************************
	private static Val[] ValArray;
	private static byte ValCount = 0;
	private static void initVal() {
		ValArray = new Val[ValMaxCountForPurse];
		for (short i = 0; i < ValArray.length; i++)
			ValArray[i] = new Val();
	}
	public static Val newVal() {
		return ValArray[ValCount++];
	}

	// ************************************************
	private static Msgcontent[] MsgcontentArray;
	private static byte MsgcontentCount = 0;
	private static void initMsgcontent() {
		MsgcontentArray = new Msgcontent[MsgcontentMaxCountForPurse];
		for (short i = 0; i < MsgcontentArray.length; i++)
			MsgcontentArray[i] = new Msgcontent();
	}
	public static Msgcontent newMsgcontent() {
		return MsgcontentArray[MsgcontentCount++];
	}

	// ************************************************
	private static GetBalance[] GetBalanceArray;
	private static byte GetBalanceCount = 0;
	private static void initGetBalance() {
		GetBalanceArray = new GetBalance[GetBalanceMaxCountForPurse];
		for (short i = 0; i < GetBalanceArray.length; i++)
			GetBalanceArray[i] = new GetBalance();
	}
	public static GetBalance newGetBalance() {
		return GetBalanceArray[GetBalanceCount++];
	}

	// ************************************************
	private static Req[] ReqArray;
	private static byte ReqCount = 0;
	private static void initReq() {
		ReqArray = new Req[ReqMaxCountForPurse];
		for (short i = 0; i < ReqArray.length; i++)
			ReqArray[i] = new Req();
	}
	public static Req newReq() {
		return ReqArray[ReqCount++];
	}

	// ************************************************
	private static ResGetData[] ResGetDataArray;
	private static byte ResGetDataCount = 0;
	private static void initResGetData() {
		ResGetDataArray = new ResGetData[ResGetDataMaxCountForPurse];
		for (short i = 0; i < ResGetDataArray.length; i++)
			ResGetDataArray[i] = new ResGetData();
	}
	public static ResGetData newResGetData() {
		return ResGetDataArray[ResGetDataCount++];
	}

	// ************************************************
	private static StartTo[] StartToArray;
	private static byte StartToCount = 0;
	private static void initStartTo() {
		StartToArray = new StartTo[StartToMaxCountForPurse];
		for (short i = 0; i < StartToArray.length; i++)
			StartToArray[i] = new StartTo();
	}
	public static StartTo newStartTo() {
		return StartToArray[StartToCount++];
	}

	// ************************************************
	private static Ack[] AckArray;
	private static byte AckCount = 0;
	private static void initAck() {
		AckArray = new Ack[AckMaxCountForPurse];
		for (short i = 0; i < AckArray.length; i++)
			AckArray[i] = new Ack();
	}
	public static Ack newAck() {
		return AckArray[AckCount++];
	}

	// ************************************************
	private static GetData[] GetDataArray;
	private static byte GetDataCount = 0;
	private static void initGetData() {
		GetDataArray = new GetData[GetDataMaxCountForPurse];
		for (short i = 0; i < GetDataArray.length; i++)
			GetDataArray[i] = new GetData();
	}
	public static GetData newGetData() {
		return GetDataArray[GetDataCount++];
	}

	// ************************************************
	private static StartFrom[] StartFromArray;
	private static byte StartFromCount = 0;
	private static void initStartFrom() {
		StartFromArray = new StartFrom[StartFromMaxCountForPurse];
		for (short i = 0; i < StartFromArray.length; i++)
			StartFromArray[i] = new StartFrom();
	}
	public static StartFrom newStartFrom() {
		return StartFromArray[StartFromCount++];
	}

	// ************************************************
	public static ResGetBalance newResGetBalance(short balance) {
		ResGetBalance _ResGetBalance = newResGetBalance();
		//The type of balance is primitive: do a simple assignment
		_ResGetBalance.balance = balance;
		return _ResGetBalance;
	}

	// ************************************************
	public static Val newVal(EncDataSymm encmess) {
		Val _Val = newVal();
		//Attributes with complex types: Use copy-method of these types.
		_Val.encmess.copy(encmess);
		return _Val;
	}

	// ************************************************
	public static Msgcontent newMsgcontent(short msgflag, PayDetails pd) {
		Msgcontent _Msgcontent = newMsgcontent();
		//The type of msgflag is primitive: do a simple assignment
		_Msgcontent.msgflag = msgflag;
		//Attributes with complex types: Use copy-method of these types.
		_Msgcontent.pd.copy(pd);
		return _Msgcontent;
	}

	// ************************************************
	public static Req newReq(EncDataSymm encmess) {
		Req _Req = newReq();
		//Attributes with complex types: Use copy-method of these types.
		_Req.encmess.copy(encmess);
		return _Req;
	}

	// ************************************************
	public static ResGetData newResGetData(PurseData dataTo) {
		ResGetData _ResGetData = newResGetData();
		//Attributes with complex types: Use copy-method of these types.
		_ResGetData.dataTo.copy(dataTo);
		return _ResGetData;
	}

	// ************************************************
	public static StartTo newStartTo(EncDataSymm encmess) {
		StartTo _StartTo = newStartTo();
		//Attributes with complex types: Use copy-method of these types.
		_StartTo.encmess.copy(encmess);
		return _StartTo;
	}

	// ************************************************
	public static Ack newAck(EncDataSymm encmess) {
		Ack _Ack = newAck();
		//Attributes with complex types: Use copy-method of these types.
		_Ack.encmess.copy(encmess);
		return _Ack;
	}

	// ************************************************
	public static StartFrom newStartFrom(short value, PurseData dataTo) {
		StartFrom _StartFrom = newStartFrom();
		//The type of value is primitive: do a simple assignment
		_StartFrom.value = value;
		//Attributes with complex types: Use copy-method of these types.
		_StartFrom.dataTo.copy(dataTo);
		return _StartFrom;
	}

	// initialize all: fill arrays
	public static void initAll() {
		initEncDataSymm();
		initSymmkey();
		initResGetBalance();
		initVal();
		initMsgcontent();
		initGetBalance();
		initReq();
		initResGetData();
		initStartTo();
		initAck();
		initGetData();
		initStartFrom();
	}

	public static void reset() {
		EncDataSymmCount = 0;

		SymmkeyCount = 0;

		ResGetBalanceCount = 0;

		ValCount = 0;

		MsgcontentCount = 0;

		GetBalanceCount = 0;

		ReqCount = 0;

		ResGetDataCount = 0;

		StartToCount = 0;

		AckCount = 0;

		GetDataCount = 0;

		StartFromCount = 0;

	}
}