invar.lib.data.DataMapper Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2016. Kang Wang. The following code is distributed under
 * the terms of the MIT license found at http://opensource.org/licenses/MIT
 */

package invar.lib.data;

import java.io.*;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.util.*;

/**
 * Created by wangkang on 11/15/2016
 */
public class DataMapper {

    static public DataMapper forJson() {
        return new DataMapper(new DataParserJson()).setVerbose(false);
    }

    static public DataMapper forXml() {
        return new DataMapper(new DataParserXml()).setVerbose(false);
    }

    static public void setMaxRecursiveFiles(int maxRecursiveFiles) {
        DataMapper.maxRecursiveFiles = Math.max(1, maxRecursiveFiles);
    }

    static public void mapFiles(Object root, String dir, final String suffix) throws Exception {
        File file = new File(dir);
        if (!file.exists()) {
            throw new IOException("Path doesn't exist:\n" + file.getAbsolutePath());
        }
        FilenameFilter filter = new FilenameFilter() {
            //@Override
            public boolean accept(File dir, String name) {
                File f = new File(dir, name);
                return f.isDirectory()
                    && !f.getName().startsWith(".")
                    && !f.getName().startsWith("_")
                    || name.endsWith(suffix);
            }
        };
        List files = new ArrayList();
        recursiveReadFile(files, file, filter);
        for (File f : files) {
            String path = f.getAbsolutePath();
            if (suffix.endsWith("xml")) {
                forXml().setPath(path).map(root, new FileInputStream(f));
                log("Read <- " + path);
            } else if (suffix.endsWith("json")) {
                forJson().setPath(path).map(root, new FileInputStream(f));
                log("Read <- " + path);
            }
        }
    }

    static private void recursiveReadFile(List all, File file, FilenameFilter filter) {
        if (all.size() > maxRecursiveFiles) {
            return;
        }
        if (file.isFile()) {
            all.add(file);
        } else if (file.isDirectory()) {
            File[] files = file.listFiles(filter);
            assert files != null;
            for (File file1 : files) {
                recursiveReadFile(all, file1, filter);
            }
        }
    }


    private final DataParser parser;

    public DataMapper(DataParser parser) {
        this.parser = parser;
    }

    public  T map(T dest, String from) throws Exception {
        if (from == null || from.length() <= 0) {
            return dest;
        }
        byte[] bytes = from.getBytes(UTF8);
        InputStream i = new ByteArrayInputStream(bytes);
        return map(dest, i);
    }

    public  T map(T dest, InputStream from) throws Exception {
        if (null == from) {
            return dest;
        }
        if (null == dest) {
            return null;
        }
        DataNode node = parser.parse(from);
        assert node != null;
        parse(dest, node);
        return dest;
    }

    private void parse(Object o, DataNode n) throws Exception {
        parse(o, n, o.getClass().getName(), o.getClass().getSimpleName());
    }

    @SuppressWarnings("unchecked")
    private void parse(Object o, DataNode n, String rule, String debug) throws Exception {
        if (o == null) {
            onError(debug + " is null.", n);
        }
        Class ClsO = loadGenericClass(rule);
        if (LinkedList.class == ClsO) {
            parseVec((LinkedList