package generated.javacard.copycardMoneySecure.copycard;

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 COMPUTEDHASHDATALENGTH = 31;

	public final static short AuthenticateMaxCountForCopycard = 1;

	public final static short PayMaxCountForCopycard = 1;

	public final static short ResRequestBalanceMaxCountForCopycard = 1;

	public final static short LoadMaxCountForCopycard = 1;

	public final static short AuthDataMaxCountForCopycard = 1;

	public final static short ResPayMaxCountForCopycard = 1;

	public final static short RequestBalanceMaxCountForCopycard = 1;

	public final static short NonceMaxCountForCopycard = 1;

	public final static short HashedDataMaxCountForCopycard = 1;

	public final static short ResAuthenticateMaxCountForCopycard = 1;

	// ************************************************
	private static HashedData[] HashedDataArray;
	private static byte HashedDataCount = 0;
	private static void initHashedData() {
		HashedDataArray = new HashedData[HashedDataMaxCountForCopycard];
		for (short i = 0; i < HashedDataArray.length; i++)
			HashedDataArray[i] = new HashedData();
	}
	public static HashedData newHashedData() {
		return HashedDataArray[HashedDataCount++];
	}

	// ************************************************
	private static Nonce[] NonceArray;
	private static byte NonceCount = 0;
	private static void initNonce() {
		NonceArray = new Nonce[NonceMaxCountForCopycard];
		for (short i = 0; i < NonceArray.length; i++)
			NonceArray[i] = new Nonce();
	}
	public static Nonce newNonce() {
		return NonceArray[NonceCount++];
	}

	// ************************************************
	private static Authenticate[] AuthenticateArray;
	private static byte AuthenticateCount = 0;
	private static void initAuthenticate() {
		AuthenticateArray = new Authenticate[AuthenticateMaxCountForCopycard];
		for (short i = 0; i < AuthenticateArray.length; i++)
			AuthenticateArray[i] = new Authenticate();
	}
	public static Authenticate newAuthenticate() {
		return AuthenticateArray[AuthenticateCount++];
	}

	// ************************************************
	private static Pay[] PayArray;
	private static byte PayCount = 0;
	private static void initPay() {
		PayArray = new Pay[PayMaxCountForCopycard];
		for (short i = 0; i < PayArray.length; i++)
			PayArray[i] = new Pay();
	}
	public static Pay newPay() {
		return PayArray[PayCount++];
	}

	// ************************************************
	private static ResRequestBalance[] ResRequestBalanceArray;
	private static byte ResRequestBalanceCount = 0;
	private static void initResRequestBalance() {
		ResRequestBalanceArray = new ResRequestBalance[ResRequestBalanceMaxCountForCopycard];
		for (short i = 0; i < ResRequestBalanceArray.length; i++)
			ResRequestBalanceArray[i] = new ResRequestBalance();
	}
	public static ResRequestBalance newResRequestBalance() {
		return ResRequestBalanceArray[ResRequestBalanceCount++];
	}

	// ************************************************
	private static Load[] LoadArray;
	private static byte LoadCount = 0;
	private static void initLoad() {
		LoadArray = new Load[LoadMaxCountForCopycard];
		for (short i = 0; i < LoadArray.length; i++)
			LoadArray[i] = new Load();
	}
	public static Load newLoad() {
		return LoadArray[LoadCount++];
	}

	// ************************************************
	private static AuthData[] AuthDataArray;
	private static byte AuthDataCount = 0;
	private static void initAuthData() {
		AuthDataArray = new AuthData[AuthDataMaxCountForCopycard];
		for (short i = 0; i < AuthDataArray.length; i++)
			AuthDataArray[i] = new AuthData();
	}
	public static AuthData newAuthData() {
		return AuthDataArray[AuthDataCount++];
	}

	// ************************************************
	private static RequestBalance[] RequestBalanceArray;
	private static byte RequestBalanceCount = 0;
	private static void initRequestBalance() {
		RequestBalanceArray = new RequestBalance[RequestBalanceMaxCountForCopycard];
		for (short i = 0; i < RequestBalanceArray.length; i++)
			RequestBalanceArray[i] = new RequestBalance();
	}
	public static RequestBalance newRequestBalance() {
		return RequestBalanceArray[RequestBalanceCount++];
	}

	// ************************************************
	private static ResPay[] ResPayArray;
	private static byte ResPayCount = 0;
	private static void initResPay() {
		ResPayArray = new ResPay[ResPayMaxCountForCopycard];
		for (short i = 0; i < ResPayArray.length; i++)
			ResPayArray[i] = new ResPay();
	}
	public static ResPay newResPay() {
		return ResPayArray[ResPayCount++];
	}

	// ************************************************
	private static ResAuthenticate[] ResAuthenticateArray;
	private static byte ResAuthenticateCount = 0;
	private static void initResAuthenticate() {
		ResAuthenticateArray = new ResAuthenticate[ResAuthenticateMaxCountForCopycard];
		for (short i = 0; i < ResAuthenticateArray.length; i++)
			ResAuthenticateArray[i] = new ResAuthenticate();
	}
	public static ResAuthenticate newResAuthenticate() {
		return ResAuthenticateArray[ResAuthenticateCount++];
	}

	// ************************************************
	public static Pay newPay(short amount, Nonce terminalchallenge) {
		Pay _Pay = newPay();
		//The type of amount is primitive: do a simple assignment
		_Pay.amount = amount;
		//Attributes with complex types: Use copy-method of these types.
		_Pay.terminalchallenge.copy(terminalchallenge);
		return _Pay;
	}

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

	// ************************************************
	public static Load newLoad(short amount, HashedData authterminal) {
		Load _Load = newLoad();
		//The type of amount is primitive: do a simple assignment
		_Load.amount = amount;
		//Attributes with complex types: Use copy-method of these types.
		_Load.authterminal.copy(authterminal);
		return _Load;
	}

	// ************************************************
	public static AuthData newAuthData(short instruction, Secret passphrase,
			Nonce challenge, short amount) {
		AuthData _AuthData = newAuthData();
		//The type of instruction is primitive: do a simple assignment
		_AuthData.instruction = instruction;
		//Attributes with complex types: Use copy-method of these types.
		_AuthData.passphrase.copy(passphrase);
		//Attributes with complex types: Use copy-method of these types.
		_AuthData.challenge.copy(challenge);
		//The type of amount is primitive: do a simple assignment
		_AuthData.amount = amount;
		return _AuthData;
	}

	// ************************************************
	public static HashedData newHashedData(byte[] hashed) {
		HashedData _HashedData = newHashedData();
		//The type of hashed is an array of primitive Types.
		Arrays.copy(hashed, _HashedData.hashed);
		return _HashedData;
	}

	// ************************************************
	public static Nonce newNonce(byte[] nonce) {
		Nonce _Nonce = newNonce();
		//The type of nonce is an array of primitive Types.
		Arrays.copy(nonce, _Nonce.nonce);
		return _Nonce;
	}

	// ************************************************
	public static ResPay newResPay(HashedData authcard) {
		ResPay _ResPay = newResPay();
		//Attributes with complex types: Use copy-method of these types.
		_ResPay.authcard.copy(authcard);
		return _ResPay;
	}

	// ************************************************
	public static ResAuthenticate newResAuthenticate(Nonce cardletchallenge) {
		ResAuthenticate _ResAuthenticate = newResAuthenticate();
		//Attributes with complex types: Use copy-method of these types.
		_ResAuthenticate.cardletchallenge.copy(cardletchallenge);
		return _ResAuthenticate;
	}

	// initialize all: fill arrays
	public static void initAll() {

		initHashedData();

		initNonce();

		initAuthenticate();

		initPay();

		initResRequestBalance();

		initLoad();

		initAuthData();

		initRequestBalance();

		initResPay();

		initResAuthenticate();

	}

	public static void reset() {

		HashedDataCount = 0;

		NonceCount = 0;

		AuthenticateCount = 0;

		PayCount = 0;

		ResRequestBalanceCount = 0;

		LoadCount = 0;

		AuthDataCount = 0;

		RequestBalanceCount = 0;

		ResPayCount = 0;

		ResAuthenticateCount = 0;

	}

}