StorageHelper.PathParser Maven / Gradle / Ivy

Go to download
package StorageHelper;

import org.apache.commons.lang.WordUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

/**
 Copyright 2016 Alianza Inc.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.

 */

public class PathParser {

    private JSONObject storedData;

    public PathParser(JSONObject data) {
        storedData = data;
    }

    /**
     * find all the paths of the key, this searches recursively, searches in JSon object from constructor
     * @param searchKey key we are searching for
     * @return list of arrays, array being the path list of all the paths
     */
    public ArrayList findPaths(String searchKey) {

        //the search takes a long time, dont' do it if  you don't have to
        if (storedData.toString().contains(searchKey))
            return findPaths(searchKey, storedData);
        else
            return new ArrayList<>();
    }


    /**
     * find all the paths in the json Object that will match the key
     * @param searchKey key searching for
     * @param searching object searching in
     * @return list of arrays, array being the path list of all the paths
     */
    private ArrayList findPaths(String searchKey, JSONObject searching) {

        Iterator keys = searching.keys();
        ArrayList allPaths = new ArrayList<>();

        //stopping case
        if (searching.has(WordUtils.capitalize(searchKey)) || searching.has(WordUtils.uncapitalize(searchKey))) {
            allPaths.add(new String[]{searchKey});
            return allPaths;
        }

        while (keys.hasNext()) {
            ArrayList foundPaths;
            String next = keys.next();
            //get the next one, either as json object or json array
            Object nextJson = null;
            try {
                nextJson = searching.get(next);
            } catch (JSONException e) {
                e.printStackTrace();
            }

            foundPaths = findPathsRecurser(searchKey, nextJson);

            //add the path to the main collection of paths
            for (String[] paths : foundPaths) {
                ArrayList pathFinder = new ArrayList<>();

                pathFinder.add(next);
                pathFinder.addAll(Arrays.asList(paths));

                allPaths.add(pathFinder.toArray(new String[pathFinder.size()]));
            }
        }

        return allPaths;
    }

    /**
     * find all the paths in the json Array that will match the key
     * @param searchKey key searching for
     * @param searching object searching in
     * @return list of arrays, array being the path list of all the paths
     */
    private ArrayList findPaths(String searchKey, JSONArray searching) {
        ArrayList allPaths = new ArrayList<>();

        for (int i = 0; i < searching.length(); ++i) {
            ArrayList foundPaths;

            Object nextJson = null;
            try {
                nextJson = searching.get(i);
            } catch (JSONException e) {
                e.printStackTrace();
            }
            foundPaths = findPathsRecurser(searchKey, nextJson);

            //add the path to the main collection of paths
            for (String[] paths : foundPaths) {
                ArrayList pathFinder = new ArrayList<>();

                pathFinder.add(String.valueOf(i));
                pathFinder.addAll(Arrays.asList(paths));

                allPaths.add(pathFinder.toArray(new String[pathFinder.size()]));
            }
        }
        return allPaths;
    }

    /**
     * recruse throught he object to find a path
     * @param searchKey
     * @param searching
     * @return
     */
    private ArrayList findPathsRecurser(String searchKey, Object searching) {
        ArrayList foundPaths = new ArrayList<>();

        if (searching.getClass().equals(JSONObject.class))
            foundPaths = findPaths(searchKey, (JSONObject) searching);
        else if (searching.getClass().equals(JSONArray.class))
            foundPaths = findPaths(searchKey, (JSONArray) searching);

        return foundPaths;
    }

}