• Home
• com.github.ddth
• ddth-commons-core
• 0.9.1.6
• source code
• DPathUtils.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.github.ddth.commons.utils.DPathUtils Maven / Gradle / Ivy

package com.github.ddth.commons.utils;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ContainerNode;
import com.fasterxml.jackson.databind.node.MissingNode;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

/**
 * Utility to access data from a hierarchy structure.
 * 
 * 

 * Notation:
 * 
 * 
 * 

 * 
. (the dot character): path separator
 * 
name: access a map's attribute specified by
 * name
 * 
[i]: access i'th element of a list/array (0-based)
 * 
 * (example: employees.[1].first_name).
 * 
 * 

 * Sample usage: assuming you have the following data structure:
 * 
 * 
 * 
 * Map<String, Object> company = new HashMap<String, Object>();
 * company.put("name", "Monster Corp.");
 * company.put("year", 2003);
 * 
 * List<Map<String, Object>> employees = new ArrayList<Map<String, Object>>();
 * company.put("employees", employees);
 * 
 * Map<String, Object> employee1 = new HashMap<String, Object>();
 * employee1.put("first_name", "Mike");
 * employee1.put("last_name", "Wazowski");
 * employee1.put("email", "[email protected]");
 * employee1.put("age", 29);
 * employees.add(employee1);
 * 
 * Map<String, Object> employee2 = new HashMap<String, Object>();
 * employee2.put("first_name", "Sulley");
 * employee2.put("last_name", "Sullivan");
 * employee2.put("email", "[email protected]");
 * employee2.put("age", 30);
 * employees.add(employee2);
 * 
 * 
 * 

 * You can access company's attributes:
 * 
 * 
 * 
 * String companyName = DPathUtils.getValue(company, "name", String.class);
 * // got string "Monster Corp."
 * 
 * Integer companyYear = DPathUtils.getValue(company, "year", Integer.class);
 * // got integer 2003
 * 
 * 
 * 

 * You can access the two employee:
 * 
 * 
 * 
 * Object user1 = DPathUtils.getValue(company, "employees.[0]");
 * Map<String, Object> user2 = DPathUtils.getValue(company, "employees.[1]", Map.class);
 * 
 * 
 * 

 * Or, employee's attributes:
 * 
 * 
 * 
 * String firstName1 = DPathUtils.getValue(company, "employees.[0].first_name", String.class);
 * Object email2 = DPathUtils.getValue(company, "employees.[1].email");
 * Long age2 = DPathUtils.getValue(company, "employees.[1].age", Long.class);
 * 
 * 
 * @author Thanh Nguyen 
 * @since 0.1.0
 */
public class DPathUtils {

    private final static Pattern PATTERN_INDEX = Pattern.compile("^\\[(.*?)\\]$");
    public final static char PATH_SEPARATOR = '.';

    private final static Pattern PATTERN_END_INDEX = Pattern.compile("^(.*)(\\[.*?\\])$");

    /**
     * Split {@code DPath} string to tokens.
     * 
     * 

     * 
{@code "a.b.c.[i].d"} or {@code "a.b.c[i].d"} will be split into
     * {@code ["a","b","c","[i]","d"]}
     * 
{@code "a.b.c.[i].[j].d"} or {@code "a.b.c[i].[j].d"} or
     * {@code "a.b.c[i][j].d"} or {@code "a.b.c.[i][j].d"} will be split into
     * {@code ["a","b","c","[i]","[j]","d"]}
     * 
     * 
     * @param dpath
     * @return
     * @since 0.6.1
     */
    @SuppressWarnings("serial")
    public final static String[] splitDpath(String dpath) {
        String[] tokens = StringUtils.split(dpath, PATH_SEPARATOR);
        List tokenList = new ArrayList() {
            {
                for (String token : tokens) {
                    List temp = new ArrayList() {
                        {
                            String _token = token;
                            Matcher m = PATTERN_END_INDEX.matcher(_token);
                            while (m.matches()) {
                                _token = m.group(1);
                                add(0, m.group(2));
                                m = PATTERN_END_INDEX.matcher(_token);
                            }
                            if (!StringUtils.isBlank(_token)) {
                                add(0, _token);
                            }
                        }
                    };
                    addAll(temp);
                }
            }
        };
        return tokenList.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
    }

    private static Object extractValue(Object target, String index) {
        if (target == null) {
            return null;
        }
        Matcher m = PATTERN_INDEX.matcher(index);
        if (m.matches()) {
            try {
                int i = Integer.parseInt(m.group(1));
                if (target instanceof Object[]) {
                    return ((Object[]) target)[i];
                }
                if (target instanceof List) {
                    return ((List) target).get(i);
                }
                throw new IllegalArgumentException("Expect an array or list for index [" + index
                        + "] but received [" + target.getClass() + "] instead.");
            } catch (IndexOutOfBoundsException e) {
                // rethrow for now
                throw e;
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("Invalid index value: " + index, e);
            }
        }
        if (target instanceof Map) {
            return ((Map) target).get(index);
        }
        throw new IllegalArgumentException(
                "Unsupported type [" + target.getClass() + "] or invalid index [" + index + "]");
    }

    private static JsonNode extractValue(JsonNode node, String index) {
        if (node == null || node instanceof NullNode || node instanceof MissingNode) {
            return null;
        }
        Matcher m = PATTERN_INDEX.matcher(index);
        if (m.matches()) {
            try {
                int i = Integer.parseInt(m.group(1));
                if (node instanceof ArrayNode) {
                    if (i >= 0 && i < node.size()) {
                        return node.get(i);
                    } else {
                        throw new IndexOutOfBoundsException(String.valueOf(i));
                    }
                }
                throw new IllegalArgumentException("Expect an ArrayNode for index [" + index
                        + "] but received [" + node.getClass() + "] instead.");
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("Invalid index value: " + index, e);
            }
        }
        if (node instanceof ObjectNode) {
            return node.get(index);
        }
        throw new IllegalArgumentException(
                "Unsupported type [" + node.getClass() + "] or invalid index [" + index + "]");
    }

    /*----------------------------------------------------------------------*/

    /**
     * Extract a date value from the target object using DPath expression. If the extracted value is
     * a string, parse it as a {@link Date} using the specified date-time format.
     * 
     * @param target
     * @param dPath
     * @param dateTimeFormat
     *            see {@link SimpleDateFormat}
     * @return
     * @since 0.6.2
     */
    public static Date getDate(Object target, String dPath, String dateTimeFormat) {
        Object obj = getValue(target, dPath);
        return ValueUtils.convertDate(obj, dateTimeFormat);
    }

    /**
     * Extract a value from the target object using DPath expression (generic
     * version).
     * 
     * @param target
     * @param dPath
     * @param clazz
     * @return
     */
    public static  T getValue(Object target, String dPath, Class clazz) {
        if (clazz == null) {
            throw new NullPointerException("Class parameter is null!");
        }
        Object temp = getValue(target, dPath);
        return ValueUtils.convertValue(temp, clazz);
    }

    /**
     * Extract a value from the target object using DPath expression (generic
     * version).
     * 
     * @param target
     * @param dPath
     * @param clazz
     * @return
     * @since 0.7.1
     */
    public static  Optional getValueOptional(Object target, String dPath, Class clazz) {
        return Optional.ofNullable(getValue(target, dPath, clazz));
    }

    /**
     * Extract a value from the target object using DPath expression.
     * 
     * @param target
     * @param dPath
     */
    public static Object getValue(Object target, String dPath) {
        String[] paths = splitDpath(dPath);
        Object result = target;
        for (String path : paths) {
            result = extractValue(result, path);
        }
        return result;
    }

    /**
     * Extract a value from the target object using DPath expression.
     * 
     * @param target
     * @param dPath
     * @return
     * @since 0.7.1
     */
    public static Optional