save-load-test

Test.java

import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.representer.Representer;

import java.io.*;
import java.nio.charset.Charset;
import java.util.*;

/**
 * Created by Brendon Butler on 7/27/2016.
 */
public class Test {

    private static DumperOptions options;
    private static File saveLocation;
    private static Map<String, Object> data;
    private static Representer representer;
    private static Scanner input;
    private static String path;
    private static Yaml yaml;

    private static void setup() {
        saveLocation = new File(path);

        if (!saveLocation.exists())
            try {
                saveLocation.createNewFile();
            } catch (IOException exception) {
                exception.printStackTrace();
            }

        setupDumper();

        yaml = new Yaml(representer, options);
        data = Collections.synchronizedMap(new LinkedHashMap<String, Object>());
    }

    private static void setupDumper() {
        options = new DumperOptions();
        representer = new Representer();

        options.setIndent(2);
        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
        options.setAllowUnicode(Charset.defaultCharset().name().contains("UTF"));
        representer.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
    }



    public static boolean contains(String key) {
        return data.containsKey(key);
    }

    public static boolean exists() {
        return data != null;
    }

    public static boolean hasValue(String key) {
        Object tempObject = data.get(key);

        return (tempObject != null);
    }

    public static boolean isEmpty() {
        return data.isEmpty() || data == null;
    }

    public static int getInteger(String key) {
        Object tempObject = get(key);

        if (tempObject instanceof Integer)
            return (Integer) tempObject;
        if (tempObject instanceof String)
            return Integer.parseInt(tempObject.toString());
        if (tempObject instanceof Number)
            return Integer.parseInt(tempObject.toString());
        return -1;
    }

    public static Object get(String key) {
        if (isEmpty())
            return null;

        if (key.contains(".")) {
            String[] nodes = key.split("\\.");
            Map<String, Object> currParent;

            if (data.containsKey(nodes[0]) && (data.get(nodes[0]) instanceof Map))
                currParent = (Map) data.get(nodes[0]);
            else return null;

            if (nodes.length > 1) {
                for (int i = 1; i < nodes.length - 1; i++) {
                    if (currParent.containsKey(nodes[i]) && (currParent.get(nodes[i]) instanceof Map))
                        currParent = (Map) currParent.get(nodes[i]);
                    else return null;
                }

                if (currParent.containsKey(nodes[nodes.length - 1]))
                    return currParent.get(nodes[nodes.length - 1]);
            }
        } else if (!contains(key) || (contains(key) && !hasValue(key)))
            return null;

        return data.get(key);
    }

    public static FileReader read(File file) {
        try {
            if (!file.exists())
                return null;
            return new FileReader(file);
        } catch (FileNotFoundException exception) {
            exception.printStackTrace();
        }
        return null;
    }

    public static boolean load() {
        setup();

        FileReader reader = read(saveLocation);

        if (reader == null) {

            data = Collections.synchronizedMap(new LinkedHashMap<String, Object>());
            return true;
        }

        data = Collections.synchronizedMap((Map<String, Object>) yaml.load(reader));

        //Health
        System.out.println(getInteger("Settings.Difficulty.Level"));
        System.out.println(getInteger("Settings.Difficulty.Locked"));
        System.out.println(getInteger("Settings.Cheats.Enabled"));
        System.out.println(getInteger("Settings.Cheats.Locked"));
        System.out.println(getInteger("Settings.GUI.Enabled"));
        System.out.println(data.toString());

        return true;
    }
    public static void save() {
        path = "test.TFsave";

        setup();

        //Settings
        set("Settings.Difficulty.Level", 1);// not saving
        set("Settings.Difficulty.Locked", 2);
        set("Settings.Cheats.Enabled", 3); // not saving
        set("Settings.Cheats.Locked", 4);
        set("Settings.GUI.Enabled", 5);

        try {
            if (!saveLocation.exists())
                saveLocation.createNewFile();

            FileWriter writer = new FileWriter(saveLocation);

            writer.write(yaml.dump(data));
            writer.flush();
            writer.close();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }

    public static void set(String key, Object object) {
        if (!exists())
            return;

        if (key.contains(".")) {
            String[] nodes = key.split("\\.");//stats.about_viewed
            // [stats](0),[about_viewed](1) length = 2

            // if data doesn't contain top-level node, create nested Maps
            if (!data.containsKey(nodes[0])) {
                Map<String, Object> currNode = new HashMap<>(), prevNode;
                currNode.put(nodes[nodes.length - 1], object);

                for (int i = nodes.length - 2; i > 0; i--) {
                    prevNode = currNode;

                    currNode = new HashMap<>();
                    currNode.put(nodes[i], prevNode);
                }
                // set top-level node to previous parent
                data.put(nodes[0], currNode);
            } else { // if data contains top-level node, work through each Map
                Map[] prevNodes = new LinkedHashMap[nodes.length - 1];

                if (nodes.length > 1) {
                    for (int i = 0; i <= nodes.length - 2; i++) {
                        if (data.containsKey(nodes[i]) && (data.get(nodes[i]) instanceof Map))
                            prevNodes[i] = new LinkedHashMap((Map) data.get(nodes[i]));
                        else if (!data.containsKey(nodes[i]))
                            prevNodes[i] = new LinkedHashMap();
                        else return; // TODO: Add protection boolean
                    }

                    prevNodes[prevNodes.length - 1].put(nodes[nodes.length - 1], object);

                    for (int i = prevNodes.length - 1; i >= 1; i--)
                        prevNodes[i - 1].put(nodes[i], prevNodes[i]);

                    data.put(nodes[0], prevNodes[0]);
                } else data.put(nodes[0], object);
            }
            return;
        }
        data.put(key, object);
    }

    public static void main(String[] args) {
        save();
        load();
    }
}