budhash · September 29, 2023 16:10
diff --git a/countries.csv b/countries.csv
diff --git a/Country.java b/Country.java
 package com.budhash.common.location;

 import com.budhash.common.utils.Converter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

 /**
 * Created by budha on 7/20/16.
 */
 public enum Country {
    XX, AND, ARE, AFG, ATG, AIA, ALB, ARM, AGO, ATA, ARG, ASM, AUT, AUS, ABW, ALA, AZE, BIH, BRB, BGD, BEL, BFA, BGR, BHR, BDI, BEN, BLM, BMU, BRN, BOL, BES, BRA, BHS, BTN, BVT, BWA, BLR, BLZ, CAN, CCK, COD, CAF, COG, CHE, CIV, COK, CHL, CMR, CHN, COL, CRI, CUB, CPV, CUW, CXR, CYP, CZE, DEU, DJI, DNK, DMA, DOM, DZA, ECU, EST, EGY, ESH, ERI, ESP, ETH, FIN, FJI, FLK, FSM, FRO, FRA, GAB, GBR, GRD, GEO, GUF, GGY, GHA, GIB, GRL, GMB, GIN, GLP, GNQ, GRC, SGS, GTM, GUM, GNB, GUY, HKG, HMD, HND, HRV, HTI, HUN, IDN, IRL, ISR, IMN, IND, IOT, IRQ, IRN, ISL, ITA, JEY, JAM, JOR, JPN, KEN, KGZ, KHM, KIR, COM, KNA, PRK, KOR, KWT, CYM, KAZ, LAO, LBN, LCA, LIE, LKA, LBR, LSO, LTU, LUX, LVA, LBY, MAR, MCO, MDA, MNE, MAF, MDG, MHL, MKD, MLI, MMR, MNG, MAC, MNP, MTQ, MRT, MSR, MLT, MUS, MDV, MWI, MEX, MYS, MOZ, NAM, NCL, NER, NFK, NGA, NIC, NLD, NOR, NPL, NRU, NIU, NZL, OMN, PAN, PER, PYF, PNG, PHL, PAK, POL, SPM, PCN, PRI, PSE, PRT, PLW, PRY, QAT, REU, ROU, SRB, RUS, RWA, SAU, SLB, SYC, SDN, SWE, SGP, SHN, SVN, SJM, SVK, SLE, SMR, SEN, SOM, SUR, SSD, STP, SLV, SXM, SYR, SWZ, TCA, TCD, ATF, TGO, THA, TJK, TKL, TLS, TKM, TUN, TON, TUR, TTO, TUV, TWN, TZA, UKR, UGA, UMI, USA, URY, UZB, VAT, VCT, VEN, VGB, VIR, VNM, VUT, WLF, WSM, YEM, MYT, ZAF, ZMB, ZWE;

    private final static Logger LOGGER = LoggerFactory.getLogger(Country.class);
    private static final CountryRecords COUNTRY_RECORD_MAP;

    static {
        COUNTRY_RECORD_MAP = new CountryRecords("src/main/resources/location/countries.csv");
        COUNTRY_RECORD_MAP.process();
    }

    public String iso2() {
        return get(CountrySchema.ISO2);
    }

    public Integer isoNum() {
        return get(CountrySchema.ISONUM);
    }

    public String countryName() {
        return get(CountrySchema.COUNTRY);
    }

    public String capital() {
        return get(CountrySchema.CAPITAL);
    }

    public String region() {
        return get(CountrySchema.REGION);
    }

    public String subRegion() {
        return get(CountrySchema.SUBREGION);
    }

    public Continent continent() {
        return get(CountrySchema.CONTINENT);
    }

    public GeoCoord coordinates() {
        return get(CountrySchema.GEOCOORD);
    }

    public String independenceStatus() {
        return get(CountrySchema.INDEPENDENT);
    }

    public Currency currency() {
        return get(CountrySchema.CURRENCY);
    }

    public String tld() {
        return get(CountrySchema.TLD);
    }

    public List<Integer> callingCode() {
        return get(CountrySchema.CALLINGCODE);
    }

    public String code(final CodeType type) {
        switch (type) {
            case EDGAR:
                return get(CountrySchema.EDGAR);
            case ITU:
                return get(CountrySchema.ITU);
            case MARC:
                return get(CountrySchema.MARC);
            case WMO:
                return get(CountrySchema.WMO);
            case DS:
                return get(CountrySchema.DS);
            case FIFA:
                return get(CountrySchema.FIFA);
            case FIPS:
                return get(CountrySchema.FIPS);
            case IOC:
                return get(CountrySchema.IOC);
            case GAUL:
                return get(CountrySchema.GAUL);
            default:
                return "";
        }
    }

    public List<String> languages() {
        return get(CountrySchema.LANGUAGES);
    }

    public List<String> languageCodes() {
        return get(CountrySchema.LANGUAGECODE);
    }

    public enum CodeType {
        EDGAR, ITU, MARC, WMO, DS, FIFA, FIPS, IOC, GAUL;
    }

    protected <T> T get(final CountrySchema column) {
        return (T) COUNTRY_RECORD_MAP.get(this).get(column);
    }

    private static interface CsvColumn {
        int getColumnNumber();

        Class getType();

        Object getDefaultValue();

        Boolean isCollection();
    }


    private static interface CsvSchema {
        List<CsvColumn> getColumns();
    }


    enum CountrySchema implements CsvColumn, CsvSchema {
        ISO3(0, String.class, ""),
        ISO2(1, String.class, ""),
        ISONUM(2, Integer.class, -1),
        COUNTRY(3, String.class, Country.XX),
        CAPITAL(4, String.class, ""),
        REGION(5, String.class, ""),
        SUBREGION(6, String.class, ""),
        CONTINENT(7, Continent.class, ""),
        LATITUDE(8, Double.class, 0.00),
        LONGITUDE(9, Double.class, 0.00),
        //BORDERS(10, Country.class, Arrays.asList(), true),
        //LANDLOCKED(11, Boolean.class, false),
        INDEPENDENT(12, String.class, ""),
        CURRENCYCODE(13, String.class, ""),
        CURRENCYNAME(14, String.class, ""),
        TLD(15, String.class, ""),
        CALLINGCODE(16, Integer.class, Arrays.asList(), true),
        EDGAR(17, String.class, ""),
        ITU(18, String.class, ""),
        MARC(19, String.class, ""),
        WMO(20, String.class, ""),
        DS(21, String.class, ""),
        FIFA(22, String.class, ""),
        FIPS(23, String.class, ""),
        IOC(24, String.class, ""),
        GAUL(25, String.class, ""),
        GEONAMEID(26, String.class, ""),
        LANGUAGES(27, String.class, Arrays.asList(), true),
        LANGUAGECODE(28, String.class, Arrays.asList(), true),
        NOTES(-1, String.class, ""),
        GEOCOORD(-1, GeoCoord.class, GeoCoord.NA()),   //this is generated
        CURRENCY(-1, Currency.class, Currency.getInstance(Locale.US));    //this is generated

        final int columnNumber;
        final Class type;
        final Object defaultValue;
        final Boolean isCollection;

        CountrySchema(final int columnNumber, final Class type, final Object defaultValue) {
            this(columnNumber, type, defaultValue, false);
        }

        CountrySchema(final int columnNumber, final Class type, final Object defaultValue, final Boolean isCollection) {
            this.columnNumber = columnNumber;
            this.type = type;
            this.defaultValue = defaultValue;
            this.isCollection = isCollection;
        }

        @Override
        public int getColumnNumber() {
            return columnNumber;
        }

        @Override
        public Class getType() {
            return type;
        }

        @Override
        public Object getDefaultValue() {
            return defaultValue;
        }

        @Override
        public Boolean isCollection() {
            return isCollection;
        }

        @Override
        public List<CsvColumn> getColumns() {
            return Arrays.asList(CountrySchema.values());
        }
    }


    private static class CsvParser {

        private static final String CSV_PATTERN = ",(?=([^\"]*\"[^\"]*\")*[^\"]*$)";
        private static final String DEFAULT_LIST_DILIMER = ",";

        private final CsvSchema schema;

        public CsvParser(final CsvSchema schema) {
            this.schema = schema;
        }

        public CsvSchema getSchema() {
            return schema;
        }

        public static <T> List<T> parseList(final CsvColumn column, final String value) {
            return Converter.parseList(value, column.getType());
        }

        public static <T> T parseValue(final CsvColumn column, final String value) {
            Optional optVal = Converter.parseValue(value, column.getType());
            //return (C) optVal.get();
            return (T) (optVal.isPresent() ? optVal.get() : column.getType().cast(column.getDefaultValue()));
        }

        public <C extends CsvColumn, V> Map<C, V> processRow(final String row) {
            final List<String> recordRow = Arrays.asList(row.split(CSV_PATTERN));
            final Map<C, V> rowMap = new HashMap<>();

            for (CsvColumn column : getSchema().getColumns()) {
                if (column.getColumnNumber() < 0)
                    continue;

                if(column.getColumnNumber() < recordRow.size()) {
                    final String cellItem = recordRow.get(column.getColumnNumber());
                    final Object value =
                        column.isCollection() ? parseList(column, cellItem.replaceAll("\"","")) : parseValue(column, cellItem);
                    rowMap.put((C) column, (V) value);
                }else{
                    rowMap.put((C) column,(V)column.getDefaultValue());
                }
            }

            return rowMap;
        }
    }

    private static class CountryRecords {
        Map<Country, Map<CsvColumn, Object>> bag = new HashMap<>();

        public Map<CsvColumn, Object> get(final Country country) {
            return bag.get(country);
        }

        public <T> T get(final Country country, final CsvColumn column) {
            return (T) column.getType().cast(bag.get(column).get(column));
        }

        final Path path;
        final CsvParser parser;
        public CountryRecords(final String path) {
            this.path = Paths.get(path);
            this.parser = new CsvParser(CountrySchema.ISO2);
        }

        protected Map<CsvColumn, Object> processRow(final String rowString){
            final Map<CsvColumn, Object> csvRow = parser.processRow(rowString);
            try {
                csvRow.put(CountrySchema.GEOCOORD, new GeoCoord((double) csvRow.get(CountrySchema.LATITUDE), (double) csvRow.get(CountrySchema.LONGITUDE)));
                final String curr = (String) csvRow.get(CountrySchema.CURRENCYCODE);
                if (null != curr && !curr.isEmpty())
                    csvRow.put(CountrySchema.CURRENCY, Currency.getInstance(curr));
            }catch (final Exception ex){
                LOGGER.error("error parsing row: {}", rowString);
            }
            return csvRow;
        }

        public void process() {
            List<String> rows = new ArrayList<>();
            bag.clear();
            try (Stream<String> stream = Files.lines(this.path)) {
                bag = stream
                    .filter(s -> null!=s && !s.isEmpty())
                    .filter(s -> !s.trim().startsWith("#"))
                    .map(this::processRow)
                    .filter(m->null!=m && !m.isEmpty())
                    .collect(
                        HashMap::new,
                        (map,e)->{
                            final Country ctry = Country.valueOf((String) e.get(CountrySchema.ISO3));
                            map.put(ctry, e);
                        },
                        Map::putAll
                    );
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }
    }
 }
diff --git a/CountryTest.java b/CountryTest.java
 public class CountryTest {
    private final static Logger LOGGER = LoggerFactory.getLogger(CountryTest.class);
    private static final String CSV_PATTERN = ",(?=([^\"]*\"[^\"]*\")*[^\"]*$)";
    @Test
    public void testCountryEnum() throws Exception {
        String fileName = "src/main/resources/location/countries.csv";
        List<String> rows = new ArrayList<>();
        List<List<String>> countryData = new ArrayList<>();

        try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
            countryData = stream
                .filter(s -> null!=s && !s.isEmpty())
                .filter(line -> !line.trim().startsWith("#"))
                .collect(
                    ArrayList::new,
                    (list,e)->{
                        if (null != e && !e.isEmpty())
                            list.add(Arrays.asList(e.split(CSV_PATTERN)));
                    },
                    ArrayList::addAll
                );
        } catch (IOException e) {
            e.printStackTrace();
        }

        for(List<String> row : countryData){
            Country ctry = Country.valueOf(row.get(0));
            validate(ctry, row);
        }
    }

    private void validate(final Country country, final List<String> row) {
        LOGGER.info("");
        LOGGER.info("validating : {}", country);

        assertThat(country.iso2()).isEqualTo(row.get(1));

        LOGGER.info("validating : isoNum -> {} = {}", country.isoNum(), row.get(2));
        assertThat(country.isoNum()).isEqualTo(Integer.valueOf(row.get(2)));

        LOGGER.info("validating : capital -> {} = {}", country.capital(), row.get(4));
        assertThat(country.capital()).isEqualTo(row.get(4));

        LOGGER.info("validating : region -> {} = {}", country.region(), row.get(5));
        assertThat(country.region()).isEqualTo(row.get(5));

        LOGGER.info("validating : subRegion -> {} = {}", country.region(), row.get(6));
        assertThat(country.subRegion()).isEqualTo(row.get(6));

        LOGGER.info("validating : continent -> {} = {}", country.continent(), row.get(7));
        assertThat(country.continent()).isEqualTo(Continent.valueOf(row.get(7)));

        LOGGER.info("validating : coordinates -> {} = ({}:{})", country.coordinates(), Double.parseDouble(row.get(8)),Double.parseDouble(row.get(9)));
        assertThat(country.coordinates()).isEqualTo(new GeoCoord(Double.parseDouble(row.get(8)),Double.parseDouble(row.get(9))));

        LOGGER.info("validating : independenceStatus -> {} = {}", country.independenceStatus(), row.get(12));
        assertThat(country.independenceStatus()).isEqualTo(row.get(12));

        LOGGER.info("validating : currency -> {} = {}", country.currency(), row.get(13));
        if(!StringUtils.isBlank(row.get(13)))
            assertThat(country.currency()).isEqualTo(Currency.getInstance(row.get(13)));
        else
            assertThat(country.currency()).isNull();

        LOGGER.info("validating : tld -> {} = {}", country.tld(), row.get(15));
        assertThat(country.tld()).isEqualTo(row.get(15));

        LOGGER.info("validating : callingCode {} = {}", country.callingCode(), row.get(16));
        assertThat(country.callingCode()).containsAll(Converter.toList(Arrays.asList(row.get(16).replaceAll("\"","").split(",")), Integer.class));

        LOGGER.info("validating : EDGAR -> {} = {}", country.code(Country.CodeType.EDGAR), row.get(17));
        assertThat(country.code(Country.CodeType.EDGAR)).isEqualTo(row.get(17));

        LOGGER.info("validating : ITU -> {} = {}", country.code(Country.CodeType.ITU), row.get(18));
        assertThat(country.code(Country.CodeType.ITU)).isEqualTo(row.get(18));

        LOGGER.info("validating : MARC -> {} = {}", country.code(Country.CodeType.MARC), row.get(19));
        assertThat(country.code(Country.CodeType.MARC)).isEqualTo(row.get(19));

        LOGGER.info("validating : WMO -> {} = {}", country.code(Country.CodeType.WMO), row.get(20));
        assertThat(country.code(Country.CodeType.WMO)).isEqualTo(row.get(20));

        LOGGER.info("validating : DS -> {} = {}", country.code(Country.CodeType.DS), row.get(21));
        assertThat(country.code(Country.CodeType.DS)).isEqualTo(row.get(21));

        LOGGER.info("validating : FIFA -> {} = {}", country.code(Country.CodeType.FIFA), row.get(22));
        assertThat(country.code(Country.CodeType.FIFA)).isEqualTo(row.get(22));

        LOGGER.info("validating : FIPS -> {} = {}", country.code(Country.CodeType.FIPS), row.get(23));
        assertThat(country.code(Country.CodeType.FIPS)).isEqualTo(row.get(23));

        LOGGER.info("validating : IOC -> {} = {}", country.code(Country.CodeType.IOC), row.get(24));
        assertThat(country.code(Country.CodeType.IOC)).isEqualTo(row.get(24));

        LOGGER.info("validating : IOC -> {} = {}", country.code(Country.CodeType.GAUL), row.get(25));
        assertThat(country.code(Country.CodeType.GAUL)).isEqualTo(row.get(25));

        LOGGER.info("validating : languages -> {} = {}", country.languages(), row.get(27));
        assertThat(country.languages()).containsAll(Converter.toList(Arrays.asList(row.get(27).replaceAll("\"","").split(",")), String.class));

        if(row.size() > 28) {
            LOGGER.info("validating : languageCodes -> {} = {}", country.languageCodes(), row.get(28));
            assertThat(country.languageCodes()).containsAll(
                Converter.toList(Arrays.asList(row.get(28).replaceAll("\"", "").split(",")), String.class));
        }
    }
 }
	package com.budhash.common.location;

	import com.budhash.common.utils.Converter;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import java.io.IOException;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.util.*;
	import java.util.stream.Collectors;
	import java.util.stream.Stream;

	/**
	* Created by budha on 7/20/16.
	*/
	public enum Country {
	XX, AND, ARE, AFG, ATG, AIA, ALB, ARM, AGO, ATA, ARG, ASM, AUT, AUS, ABW, ALA, AZE, BIH, BRB, BGD, BEL, BFA, BGR, BHR, BDI, BEN, BLM, BMU, BRN, BOL, BES, BRA, BHS, BTN, BVT, BWA, BLR, BLZ, CAN, CCK, COD, CAF, COG, CHE, CIV, COK, CHL, CMR, CHN, COL, CRI, CUB, CPV, CUW, CXR, CYP, CZE, DEU, DJI, DNK, DMA, DOM, DZA, ECU, EST, EGY, ESH, ERI, ESP, ETH, FIN, FJI, FLK, FSM, FRO, FRA, GAB, GBR, GRD, GEO, GUF, GGY, GHA, GIB, GRL, GMB, GIN, GLP, GNQ, GRC, SGS, GTM, GUM, GNB, GUY, HKG, HMD, HND, HRV, HTI, HUN, IDN, IRL, ISR, IMN, IND, IOT, IRQ, IRN, ISL, ITA, JEY, JAM, JOR, JPN, KEN, KGZ, KHM, KIR, COM, KNA, PRK, KOR, KWT, CYM, KAZ, LAO, LBN, LCA, LIE, LKA, LBR, LSO, LTU, LUX, LVA, LBY, MAR, MCO, MDA, MNE, MAF, MDG, MHL, MKD, MLI, MMR, MNG, MAC, MNP, MTQ, MRT, MSR, MLT, MUS, MDV, MWI, MEX, MYS, MOZ, NAM, NCL, NER, NFK, NGA, NIC, NLD, NOR, NPL, NRU, NIU, NZL, OMN, PAN, PER, PYF, PNG, PHL, PAK, POL, SPM, PCN, PRI, PSE, PRT, PLW, PRY, QAT, REU, ROU, SRB, RUS, RWA, SAU, SLB, SYC, SDN, SWE, SGP, SHN, SVN, SJM, SVK, SLE, SMR, SEN, SOM, SUR, SSD, STP, SLV, SXM, SYR, SWZ, TCA, TCD, ATF, TGO, THA, TJK, TKL, TLS, TKM, TUN, TON, TUR, TTO, TUV, TWN, TZA, UKR, UGA, UMI, USA, URY, UZB, VAT, VCT, VEN, VGB, VIR, VNM, VUT, WLF, WSM, YEM, MYT, ZAF, ZMB, ZWE;

	private final static Logger LOGGER = LoggerFactory.getLogger(Country.class);
	private static final CountryRecords COUNTRY_RECORD_MAP;

	static {
	COUNTRY_RECORD_MAP = new CountryRecords("src/main/resources/location/countries.csv");
	COUNTRY_RECORD_MAP.process();
	}

	public String iso2() {
	return get(CountrySchema.ISO2);
	}

	public Integer isoNum() {
	return get(CountrySchema.ISONUM);
	}

	public String countryName() {
	return get(CountrySchema.COUNTRY);
	}

	public String capital() {
	return get(CountrySchema.CAPITAL);
	}

	public String region() {
	return get(CountrySchema.REGION);
	}

	public String subRegion() {
	return get(CountrySchema.SUBREGION);
	}

	public Continent continent() {
	return get(CountrySchema.CONTINENT);
	}

	public GeoCoord coordinates() {
	return get(CountrySchema.GEOCOORD);
	}

	public String independenceStatus() {
	return get(CountrySchema.INDEPENDENT);
	}

	public Currency currency() {
	return get(CountrySchema.CURRENCY);
	}

	public String tld() {
	return get(CountrySchema.TLD);
	}

	public List<Integer> callingCode() {
	return get(CountrySchema.CALLINGCODE);
	}

	public String code(final CodeType type) {
	switch (type) {
	case EDGAR:
	return get(CountrySchema.EDGAR);
	case ITU:
	return get(CountrySchema.ITU);
	case MARC:
	return get(CountrySchema.MARC);
	case WMO:
	return get(CountrySchema.WMO);
	case DS:
	return get(CountrySchema.DS);
	case FIFA:
	return get(CountrySchema.FIFA);
	case FIPS:
	return get(CountrySchema.FIPS);
	case IOC:
	return get(CountrySchema.IOC);
	case GAUL:
	return get(CountrySchema.GAUL);
	default:
	return "";
	}
	}

	public List<String> languages() {
	return get(CountrySchema.LANGUAGES);
	}

	public List<String> languageCodes() {
	return get(CountrySchema.LANGUAGECODE);
	}

	public enum CodeType {
	EDGAR, ITU, MARC, WMO, DS, FIFA, FIPS, IOC, GAUL;
	}

	protected <T> T get(final CountrySchema column) {
	return (T) COUNTRY_RECORD_MAP.get(this).get(column);
	}

	private static interface CsvColumn {
	int getColumnNumber();

	Class getType();

	Object getDefaultValue();

	Boolean isCollection();
	}


	private static interface CsvSchema {
	List<CsvColumn> getColumns();
	}


	enum CountrySchema implements CsvColumn, CsvSchema {
	ISO3(0, String.class, ""),
	ISO2(1, String.class, ""),
	ISONUM(2, Integer.class, -1),
	COUNTRY(3, String.class, Country.XX),
	CAPITAL(4, String.class, ""),
	REGION(5, String.class, ""),
	SUBREGION(6, String.class, ""),
	CONTINENT(7, Continent.class, ""),
	LATITUDE(8, Double.class, 0.00),
	LONGITUDE(9, Double.class, 0.00),
	//BORDERS(10, Country.class, Arrays.asList(), true),
	//LANDLOCKED(11, Boolean.class, false),
	INDEPENDENT(12, String.class, ""),
	CURRENCYCODE(13, String.class, ""),
	CURRENCYNAME(14, String.class, ""),
	TLD(15, String.class, ""),
	CALLINGCODE(16, Integer.class, Arrays.asList(), true),
	EDGAR(17, String.class, ""),
	ITU(18, String.class, ""),
	MARC(19, String.class, ""),
	WMO(20, String.class, ""),
	DS(21, String.class, ""),
	FIFA(22, String.class, ""),
	FIPS(23, String.class, ""),
	IOC(24, String.class, ""),
	GAUL(25, String.class, ""),
	GEONAMEID(26, String.class, ""),
	LANGUAGES(27, String.class, Arrays.asList(), true),
	LANGUAGECODE(28, String.class, Arrays.asList(), true),
	NOTES(-1, String.class, ""),
	GEOCOORD(-1, GeoCoord.class, GeoCoord.NA()), //this is generated
	CURRENCY(-1, Currency.class, Currency.getInstance(Locale.US)); //this is generated

	final int columnNumber;
	final Class type;
	final Object defaultValue;
	final Boolean isCollection;

	CountrySchema(final int columnNumber, final Class type, final Object defaultValue) {
	this(columnNumber, type, defaultValue, false);
	}

	CountrySchema(final int columnNumber, final Class type, final Object defaultValue, final Boolean isCollection) {
	this.columnNumber = columnNumber;
	this.type = type;
	this.defaultValue = defaultValue;
	this.isCollection = isCollection;
	}

	@Override
	public int getColumnNumber() {
	return columnNumber;
	}

	@Override
	public Class getType() {
	return type;
	}

	@Override
	public Object getDefaultValue() {
	return defaultValue;
	}

	@Override
	public Boolean isCollection() {
	return isCollection;
	}

	@Override
	public List<CsvColumn> getColumns() {
	return Arrays.asList(CountrySchema.values());
	}
	}


	private static class CsvParser {

	private static final String CSV_PATTERN = ",(?=([^\"]\"[^\"]\")[^\"]$)";
	private static final String DEFAULT_LIST_DILIMER = ",";

	private final CsvSchema schema;

	public CsvParser(final CsvSchema schema) {
	this.schema = schema;
	}

	public CsvSchema getSchema() {
	return schema;
	}

	public static <T> List<T> parseList(final CsvColumn column, final String value) {
	return Converter.parseList(value, column.getType());
	}

	public static <T> T parseValue(final CsvColumn column, final String value) {
	Optional optVal = Converter.parseValue(value, column.getType());
	//return (C) optVal.get();
	return (T) (optVal.isPresent() ? optVal.get() : column.getType().cast(column.getDefaultValue()));
	}

	public <C extends CsvColumn, V> Map<C, V> processRow(final String row) {
	final List<String> recordRow = Arrays.asList(row.split(CSV_PATTERN));
	final Map<C, V> rowMap = new HashMap<>();

	for (CsvColumn column : getSchema().getColumns()) {
	if (column.getColumnNumber() < 0)
	continue;

	if(column.getColumnNumber() < recordRow.size()) {
	final String cellItem = recordRow.get(column.getColumnNumber());
	final Object value =
	column.isCollection() ? parseList(column, cellItem.replaceAll("\"","")) : parseValue(column, cellItem);
	rowMap.put((C) column, (V) value);
	}else{
	rowMap.put((C) column,(V)column.getDefaultValue());
	}
	}

	return rowMap;
	}
	}

	private static class CountryRecords {
	Map<Country, Map<CsvColumn, Object>> bag = new HashMap<>();

	public Map<CsvColumn, Object> get(final Country country) {
	return bag.get(country);
	}

	public <T> T get(final Country country, final CsvColumn column) {
	return (T) column.getType().cast(bag.get(column).get(column));
	}

	final Path path;
	final CsvParser parser;
	public CountryRecords(final String path) {
	this.path = Paths.get(path);
	this.parser = new CsvParser(CountrySchema.ISO2);
	}

	protected Map<CsvColumn, Object> processRow(final String rowString){
	final Map<CsvColumn, Object> csvRow = parser.processRow(rowString);
	try {
	csvRow.put(CountrySchema.GEOCOORD, new GeoCoord((double) csvRow.get(CountrySchema.LATITUDE), (double) csvRow.get(CountrySchema.LONGITUDE)));
	final String curr = (String) csvRow.get(CountrySchema.CURRENCYCODE);
	if (null != curr && !curr.isEmpty())
	csvRow.put(CountrySchema.CURRENCY, Currency.getInstance(curr));
	}catch (final Exception ex){
	LOGGER.error("error parsing row: {}", rowString);
	}
	return csvRow;
	}

	public void process() {
	List<String> rows = new ArrayList<>();
	bag.clear();
	try (Stream<String> stream = Files.lines(this.path)) {
	bag = stream
	.filter(s -> null!=s && !s.isEmpty())
	.filter(s -> !s.trim().startsWith("#"))
	.map(this::processRow)
	.filter(m->null!=m && !m.isEmpty())
	.collect(
	HashMap::new,
	(map,e)->{
	final Country ctry = Country.valueOf((String) e.get(CountrySchema.ISO3));
	map.put(ctry, e);
	},
	Map::putAll
	);
	} catch (final IOException e) {
	e.printStackTrace();
	}
	}
	}
	}
	public class CountryTest {
	private final static Logger LOGGER = LoggerFactory.getLogger(CountryTest.class);
	private static final String CSV_PATTERN = ",(?=([^\"]\"[^\"]\")[^\"]$)";
	@Test
	public void testCountryEnum() throws Exception {
	String fileName = "src/main/resources/location/countries.csv";
	List<String> rows = new ArrayList<>();
	List<List<String>> countryData = new ArrayList<>();

	try (Stream<String> stream = Files.lines(Paths.get(fileName))) {
	countryData = stream
	.filter(s -> null!=s && !s.isEmpty())
	.filter(line -> !line.trim().startsWith("#"))
	.collect(
	ArrayList::new,
	(list,e)->{
	if (null != e && !e.isEmpty())
	list.add(Arrays.asList(e.split(CSV_PATTERN)));
	},
	ArrayList::addAll
	);
	} catch (IOException e) {
	e.printStackTrace();
	}

	for(List<String> row : countryData){
	Country ctry = Country.valueOf(row.get(0));
	validate(ctry, row);
	}
	}

	private void validate(final Country country, final List<String> row) {
	LOGGER.info("");
	LOGGER.info("validating : {}", country);

	assertThat(country.iso2()).isEqualTo(row.get(1));

	LOGGER.info("validating : isoNum -> {} = {}", country.isoNum(), row.get(2));
	assertThat(country.isoNum()).isEqualTo(Integer.valueOf(row.get(2)));

	LOGGER.info("validating : capital -> {} = {}", country.capital(), row.get(4));
	assertThat(country.capital()).isEqualTo(row.get(4));

	LOGGER.info("validating : region -> {} = {}", country.region(), row.get(5));
	assertThat(country.region()).isEqualTo(row.get(5));

	LOGGER.info("validating : subRegion -> {} = {}", country.region(), row.get(6));
	assertThat(country.subRegion()).isEqualTo(row.get(6));

	LOGGER.info("validating : continent -> {} = {}", country.continent(), row.get(7));
	assertThat(country.continent()).isEqualTo(Continent.valueOf(row.get(7)));

	LOGGER.info("validating : coordinates -> {} = ({}:{})", country.coordinates(), Double.parseDouble(row.get(8)),Double.parseDouble(row.get(9)));
	assertThat(country.coordinates()).isEqualTo(new GeoCoord(Double.parseDouble(row.get(8)),Double.parseDouble(row.get(9))));

	LOGGER.info("validating : independenceStatus -> {} = {}", country.independenceStatus(), row.get(12));
	assertThat(country.independenceStatus()).isEqualTo(row.get(12));

	LOGGER.info("validating : currency -> {} = {}", country.currency(), row.get(13));
	if(!StringUtils.isBlank(row.get(13)))
	assertThat(country.currency()).isEqualTo(Currency.getInstance(row.get(13)));
	else
	assertThat(country.currency()).isNull();

	LOGGER.info("validating : tld -> {} = {}", country.tld(), row.get(15));
	assertThat(country.tld()).isEqualTo(row.get(15));

	LOGGER.info("validating : callingCode {} = {}", country.callingCode(), row.get(16));
	assertThat(country.callingCode()).containsAll(Converter.toList(Arrays.asList(row.get(16).replaceAll("\"","").split(",")), Integer.class));

	LOGGER.info("validating : EDGAR -> {} = {}", country.code(Country.CodeType.EDGAR), row.get(17));
	assertThat(country.code(Country.CodeType.EDGAR)).isEqualTo(row.get(17));

	LOGGER.info("validating : ITU -> {} = {}", country.code(Country.CodeType.ITU), row.get(18));
	assertThat(country.code(Country.CodeType.ITU)).isEqualTo(row.get(18));

	LOGGER.info("validating : MARC -> {} = {}", country.code(Country.CodeType.MARC), row.get(19));
	assertThat(country.code(Country.CodeType.MARC)).isEqualTo(row.get(19));

	LOGGER.info("validating : WMO -> {} = {}", country.code(Country.CodeType.WMO), row.get(20));
	assertThat(country.code(Country.CodeType.WMO)).isEqualTo(row.get(20));

	LOGGER.info("validating : DS -> {} = {}", country.code(Country.CodeType.DS), row.get(21));
	assertThat(country.code(Country.CodeType.DS)).isEqualTo(row.get(21));

	LOGGER.info("validating : FIFA -> {} = {}", country.code(Country.CodeType.FIFA), row.get(22));
	assertThat(country.code(Country.CodeType.FIFA)).isEqualTo(row.get(22));

	LOGGER.info("validating : FIPS -> {} = {}", country.code(Country.CodeType.FIPS), row.get(23));
	assertThat(country.code(Country.CodeType.FIPS)).isEqualTo(row.get(23));

	LOGGER.info("validating : IOC -> {} = {}", country.code(Country.CodeType.IOC), row.get(24));
	assertThat(country.code(Country.CodeType.IOC)).isEqualTo(row.get(24));

	LOGGER.info("validating : IOC -> {} = {}", country.code(Country.CodeType.GAUL), row.get(25));
	assertThat(country.code(Country.CodeType.GAUL)).isEqualTo(row.get(25));

	LOGGER.info("validating : languages -> {} = {}", country.languages(), row.get(27));
	assertThat(country.languages()).containsAll(Converter.toList(Arrays.asList(row.get(27).replaceAll("\"","").split(",")), String.class));

	if(row.size() > 28) {
	LOGGER.info("validating : languageCodes -> {} = {}", country.languageCodes(), row.get(28));
	assertThat(country.languageCodes()).containsAll(
	Converter.toList(Arrays.asList(row.get(28).replaceAll("\"", "").split(",")), String.class));
	}
	}
	}