/* package whatever; // don't place package name! */
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
import java.lang.reflect.ParameterizedType;
import java.util.stream.Collectors;
 
/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
 
	interface SecondaryCode{}
 
    enum AccumSecondaryCode implements SecondaryCode {
        MORE_THREE_YEARS("07");
 
        private AccumSecondaryCode( String code ) {};
    }
 
    public enum CreditSecondaryCode implements SecondaryCode {
        UP_TO_ONE_YEAR("04");
 
        private CreditSecondaryCode( String code ) {};
    }
 
    abstract static class PrimaryOperation<CODE extends SecondaryCode> {
    	// can't use diamond in with anonymous classes in java-8
        static PrimaryOperation<AccumSecondaryCode> ACCUM = new PrimaryOperation<AccumSecondaryCode>() {};
 
        static PrimaryOperation<CreditSecondaryCode> CREDIT = new PrimaryOperation<CreditSecondaryCode>(){};
 
        private PrimaryOperation() {}
 
        @SuppressWarnings("unchecked")
        public List<CODE> validSecondaryCodes() {
            ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass();
 
            Class<?> parameter = (Class<?>)type.getActualTypeArguments()[0];
 
            return Arrays.stream(parameter.getEnumConstants()).map( o -> (CODE)o ).collect( Collectors.toList() );
        }
    }
 
    static <CODE extends SecondaryCode> void createAccount( PrimaryOperation<CODE> primary, CODE secondary ) {
    }
 
	public static void main (String[] args) throws java.lang.Exception
	{
	    createAccount( PrimaryOperation.ACCUM, AccumSecondaryCode.MORE_THREE_YEARS );
 
        // this does not compile
        //createAccount( PrimaryOperation.ACCUM, CreditSecondaryCode.UP_TO_ONE_YEAR );
 
        System.out.println( PrimaryOperation.CREDIT.validSecondaryCodes() );
	}
}

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