API eCrud - The configuration API everyone can enjoy!

Hello! I re-created my old config API, but I made it better. It's now...

- More efficient
- Twice as user-friendly
- Supports a lot of file types
- Speedy
- Easy saving, setting, getting, and checking of data

I call it eCrud! (eCrud Creates Robust and Useful Datafiles)

Need I say more? It currently uses two classes, the config itself and the config manager.

ConfigManager.java (Pastebin: <Click>)

Show Spoiler Hide Spoiler

Code:java

 
import java.io.File;
import java.util.HashMap;
 
public class ConfigManager
{
    private static final HashMap<String, Config> configFiles = new HashMap<>();
 
    /**
     * Create a configuration file. Creates the file, adds it to the registry, and returns the new instance
     * @param folder Folder to store the config file in
     * @param name Name of file (NOTE: Include file extension!)
     * @return The new Config instance.
     */
    public static Config createConfig(File folder, String name)
    {
        Config cfg = new Config(folder, name);
 
        if(!configFiles.containsKey(name))
        {
            if(cfg.create())
            {
                configFiles.put(name, cfg);
                return cfg;
            }
            else
            {
                System.err.println("Error: Could not create file.");
                return null;
            }
        }
        else
        {
            return getConfig(name);
        }
    }
 
    /**
     * Gets the config from the registry.
     * @param name Name of config (Checks through config database, throws an InvalidConfigException if the inputted config isn't registered)
     * @return The config selected from the registry.
     */
    public static Config getConfig(String name)
    {
        if(configFiles.containsKey(name))
        {
            return configFiles.get(name);
        }
        else
        {
            throw new InvalidConfigException("Could not locate file " + name + "! (Was not registered)");
        }
    }
 
    /**
     * Deletes config's file and registry.
     * @param name Name of config (Checks through config database, throws an InvalidConfigException if the inputted config isn't registered)
     * @return True if deleted successfully, false if something went wrong.
     */
    public static boolean deleteConfig(String name)
    {
        if(configFiles.containsKey(name))
        {
            Config cfg = configFiles.get(name);
 
            if(cfg.delete())
            {
                configFiles.remove(name);
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            throw new InvalidConfigException("Could not delete file " + name + "! (Was not registered)");
        }
    }
 
    /**
     * Recreate a config (In the event of data corruption, updated cfgs, etc.)
     * @param name Name of config (Checks through config database, throws an InvalidConfigException if the inputted config isn't registered)
     * @return True if recreated, false if something went wrong.
     */
    public static boolean recreateConfig(String name)
    {
        if(configFiles.containsKey(name))
        {
            Config cfg = configFiles.get(name);
 
            return cfg.recreate();
        }
        else
        {
            throw new InvalidConfigException("Could not find file " + name + "! (Was not registered)");
        }
    }
 
    /**
     * Save all currently registered configurations.
     */
    public static void saveAllConfigs()
    {
        for(Config cfg : configFiles.values())
        {
            cfg.save();
        }
    }
 
    /**
     * Use in your plugin's onDisable method. Just a precaution, to save all the files.
     * Actually, don't. Ignore that top part. Save it if you want, it can cause issues if someone edits the file then reloads (It deletes the changes)
     */
    public static void onDisable()
    {
        for(Config cfg : configFiles.values())
        {
            cfg.save();
        }
        configFiles.clear();
    }
}
 
/**
* Exception that's thrown in the event an invalid configuration is used/found.
* @author Hydroxocobalamin
*/
class InvalidConfigException extends RuntimeException
{
    public InvalidConfigException(String ex)
    {
        super(ex);
    }
}
 

Config.java (Pastebin: <Click>)

Show Spoiler Hide Spoiler

Code:java

 
import java.io.File;
import java.io.IOException;
import org.bukkit.configuration.file.YamlConfiguration;
 
/**
* @author Hydroxocobalamin. All rights reserved.
* License: Nobody cares... honestly.
*/
public final class Config
{
    private File configFile;
    private YamlConfiguration config;
    private String fileName;
 
    /**
     * Default constructor for configurations.
     * @param folder Folder to store the config in
     * @param name Name of the file (Specify extension!)
     */
    public Config(File folder, String name)
    {
        fileName = name;
        configFile = new File(folder, name);
    }
 
    /**
     * Get the config file
     * @return config file
     */
    public File getFile()
    {
        return configFile;
    }
 
    /**
     * Get the YamlConfiguration paired with the config
     * @return The config
     */
    public YamlConfiguration getYaml()
    {
        return config;
    }
 
    /**
     * Get the name of the file
     * @return File name
     */
    public String getFileName()
    {
        return fileName;
    }
 
    /**
     * Get the folder the config is stored in
     * @return The config's folder
     */
    public File getFolder()
    {
        return configFile.getParentFile();
    }
 
    /**
     * Create a configuration section
     * @param path Section to create
     */
    public void createSection(String path)
    {
        if(!config.contains(path))
        {
            config.createSection(path);
        }
    }
 
    /**
     * Set the value to the config file.
     * @param path Path to store the variable
     * @param value Value to store on the path
     * @return The object specified
     */
    public Object setValue(String path, Object value)
    {
        if(hasValue(path, true))
        {
            config.set(path, value);
        }
        else
        {
            config.set(path, value);
        }
        return value;
    }
 
    /**
     * Check the config for a value
     * @param path Path to find the variable
     * @return Does the config have the value?
     */
    public boolean hasValue(String path)
    {
        if(config.contains(path))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    /**
     * Check the config for a value
     * @param path Path to find the variable
     * @param createIfNot If it can't find the path, create it?
     * @return Does the config have the value?
     */
    public boolean hasValue(String path, boolean createIfNot)
    {
        if(config.contains(path))
        {
            return true;
        }
        else
        {
            if(createIfNot)
            {
                config.createSection(path);
            }
            return false;
        }
    }
 
    /**
     * Get an object from config, return null if it couldn't find the value
     * @param path Path to find the value
     * @return Config collected from file
     */
    public Object getValue(String path)
    {
        if(config.contains(path))
        {
            return config.get(path);
        }
        else
        {
            config.createSection(path);
        }
        return null;
    }
 
    /**
     * Get an object from config, return default if it couldn't find the path
     * @param path Path to find the value
     * @param def Default value, if it couldn't find one in the config
     * @return Config collected from file
     */
    public Object getValue(String path, Object def)
    {
        if(config.contains(path))
        {
            return config.get(path);
        }
        else
        {
            config.createSection(path);
            config.set(path, def);
            return def;
        }
    }
 
    /**
     * Create the config file, and folder.
     * @return True if it was created, false if an exception was thrown.
     */
    public boolean create()
    {
        try
        {
            if(!getFolder().exists())
            {
                getFolder().mkdir();
            }
 
            configFile.createNewFile();
            config = YamlConfiguration.loadConfiguration(configFile);
            return true;
        }
        catch(IOException ex)
        {
            System.err.println("Error while creating file (IOException): ");
            ex.printStackTrace();
            return false;
        }
    }
 
    /**
     * Delete the config, then re-create it.
     * @return True if it worked, false if an exception was thrown.
     */
    public boolean recreate()
    {
        configFile.delete();
        config = null;
 
        try
        {
            if(!getFolder().exists())
            {
                getFolder().mkdir();
            }
 
            configFile.createNewFile();
            config = YamlConfiguration.loadConfiguration(configFile);
            return true;
        }
        catch (IOException ex)
        {
            System.err.println("Error while creating file (IOException): ");
            ex.printStackTrace();
            return false;
        }
    }
 
    /**
     * Delete the config file.
     * @return True or false, depending on if it was deleted or not.
     */
    public boolean delete()
    {
        return configFile.delete();
    }
 
    /**
     * Delete the folder the config is stored in.
     * @return True or false, depending on if it was deleted or not.
     */
    public boolean deleteFolder()
    {
        return getFolder().delete();
    }
 
 
    /**
     * Save the config to disk.
     * @return True if it saved, false if an exception was thrown
     */
    public boolean save()
    {
        try
        {
            config.save(configFile);
            return true;
        }
        catch(IOException ex)
        {
            return false;
        }
    }
}
 

Example Plugin (Pastebin: <Click>)

Show Spoiler Hide Spoiler

Code:java

 
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.java.JavaPlugin;
 
public class ExamplePlugin extends JavaPlugin implements Listener
{
    private Config cfg;
 
    public static String joinMessage = "&cWelcome, &6{player}!";
    public static boolean replaceJoinMessage = true;
 
    @Override
    public void onEnable()
    {
        Bukkit.getPluginManager().registerEvents(this, this);
        cfg = ConfigManager.createConfig(getDataFolder(), "config.yml");
 
        if(cfg.getYaml().contains("join.message") && cfg.getYaml().contains("join.replacemessage"))
        {
            replaceJoinMessage = (boolean)cfg.getValue("join.replacemessage", true);
            joinMessage = (String)cfg.getValue("join.message");
        }
        else
        {
            cfg.setValue("join.message", joinMessage);
            cfg.setValue("join.replacemessage", true);
            cfg.save();
        }
    }
 
    @Override
    public void onDisable()
    {
        ConfigManager.onDisable();
    }
 
    @EventHandler
    public void join(PlayerJoinEvent event)
    {
        Player player = event.getPlayer();
 
        if(replaceJoinMessage)
        {
            event.setJoinMessage(joinMessage);
        }
    }
}
 

So, what do you think? Should I add more, take away some, change something?

Thanks for reading!
-Hydroxocobalamin (OCHbl)

Note: This software is protected by the HDC license. Read it here:

Show Spoiler Hide Spoiler

HDC = Hydroxocobalamin doesn't care.
Just lemme see your project when you release it! <3

 

Very useful, Thanks!

 

jjssman No problem!

 

Could you explain the methods more? And make a bigger example.. like saving diff things. for example. making when a player goes they go under a Player: path. and saving a hashmap using a player and int would be helpful too. nice api tho

 

@XxZHALO13Xx Well, I'll write some code tonight and update the post! Thanks for providing feedback, that's what makes products better you know!

 

@Dudemister1999 You should change your create method to:

Code:

   public static Config createConfig(File folder, String name) {
        Config cfg = new Config(folder, name);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        if (!configFiles.containsKey(name)) {
            if (cfg.create()) {
                configFiles.put(name, cfg);
                return cfg;
            } else {
                System.err.println("Error: Could not create file " + name + ".");
                return null;
            }
        } else {
            return getConfig(name);
        }
    }

so we can also create files in a subfolder
for example:

Code:

Config config = (new File(getDataFolder() + File.seperator + "submap name");

before it did gave an error that it couldn't find the path but now if it can't find it it will create it

 

@Dmrtje I'm in the works of a complete configuration control suite. When I finish it, I'll update the OP. Your suggestion will be implemented, thanks!

 

@Dudemister1999 no problem

EDIT:

its a really nice easy to use API. But the saving could be a little easier cause now you need to do ConfigManager.getConfig(String configname).save();
But i think it wil be nicer if you just could do config.save(); and config.reload(); oow and maybe add a remove method cause now you need to do config.getYaml().set(value, null);

 

@Dmrtje I've actually made a lot of adjustments. Instead of using ConfigManager to get to your config, try storing an instance (Sort of how JavaPlugin has a getConfig() method). New features include config.set(String path, Object value) (Auto saves), <T> T config.get(String path) & <T> T config.get(String path, Class type), and a whole lot more. ConfigManager has gotten an update as well, to include changing the .yml of the config at will, reloading, clearing, saving copies to other places, and more! I'm making a site to store my plugin code, and I'll reset the OP to link to it.

 

It only does anything if you decide to take action upon the infringement of that license, of which you may or may not be notified of.

 

Just like any law. It would be useless if no one is enforcing it!

How is this more efficient? It just looks like a wrapper class to me. It uses the same YML library that Bukkit uses. Also you can create any file with any type but the format will still be in YML since you are using a YML library.

 

@xTrollxDudex
I really don't intend to enforce it, I just wanted to feel special. I removed it in the new version.

@teej107
I meant efficient as in it allows you to do what you would with a YamlConfiguration faster. (Creating, saving, reloading, etc.)
Soon (By which I mean when I get back), I'm adding a JSON config.

 

Wait.. what? Is it me or you are saving the config file each time a value is set or a section is created?

 

@Totom3 This version, yes. Back when I was naive, and thought saving every time was a smart usage of disc. It's since been changed.

 

@Dudemister1999 Oh you scared me, you should update the post.

 

@Totom3 I will. Trying to get the site up, so people can get all my code from there.

 

@Dudemister1999 What makes yours better than Skionz's DataApi?

 

@bwfcwalshy I haven't seen his, I should check it out! It was my first useful resource. Also, if you're questioning the "More efficient" bit, that's comparing it to the older version of it.

Soon (By which I mean when my website is fully functional), I'm adding a JSON config as well. Maybe I'll go farther, we'll just see where things go.