still dont understand

all i want to do is have a yml file that contains a list of players. i would like to somewhere in my code take a player that has used a command and see if there name is on that list. that's all.
thank you in advanced

 

yml isn't meant to be a plain text file, it's meant to follow a specific format. You can have an array of player names stored in yml under a key such as "users:" but you can't just put a list of playernames with no formatting.

That said, nothing forces you to use yml. You can read and write standard text files too and can define custom formats, such as a simple one-per-line list yourself.

 

No what i am trying to do is ban ppl from a world upon death so the format would be world: then a list of everyone who is banned from that world

 

You have to have a (Array)List for each world containing the player names, than save it with:
config.set("worldName", yourList);
and later you can read it with:
List<Object> = config.getList("worldName");
of course you need to do a bit of casting to get all to your plugin internal structure.

 

Yea that's what I'm having trouble with is the casting part. I keep getting cannot convert list to a string and some stuff like that btw that's an awesome dog.

 

Continuing V10lators code:

Code:

List<Object> list = config.getList("worldName");
ArrayList<String> bannedPlayers = new ArrayList<String>();
for (Object o : list) {
    if (o instanceof String) {
        bannedPlayers.add((String) o);
    }
}

 

Thank you guys for the help. Sorry if I'm being a bother. I usually try to solve these problems on my own but sometimes I just have to admit that I don't know everything. I will try what u guys said as soon as I get home and I'll post an update.

 

If you eventually get fed up with YML (as I did), I made my own configuration utility that I use for my plugins.

I'd be happy to share it with you, if you'd ever want to use it.
You essentially construct (or load it from file) a tree of ConfigNodes, then read it (or save it to file).

Code:java

package org.nubcraft.nubbukkit.util.config;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
 
public class ConfigNode
{
	//Variables
	public final static int INDENT =  4;
	private String name, value;
	private HashMap<String, ConfigNode> children;
	//Constructors
	public ConfigNode(String name, String value)
	{
		this.name = name;
		this.value = value;
		children = new HashMap<String, ConfigNode>();
	}
	public ConfigNode(String name)
	{
		this.name = name;
		value = null;
		children = new HashMap<String, ConfigNode>();
	}
	private ConfigNode()
	{
		name = "Root";
		value = null;
		children = new HashMap<String, ConfigNode>();
	}
	//get methods
	public String getName()
	{
		return name;
	}
	public boolean hasValue()
	{
		return value != null;
	}
	public String get()
	{
		return value;
	}
	public String getString()
	{
		return value;
	}
	public Boolean getBoolean()
	{
		String val = value.toString();
		if(val.equalsIgnoreCase("true"))
			return true;
		return false;
	}
	public Integer getInteger()
	{
		try
		{
			int i = Integer.parseInt(value);
			return i;
		}
		catch(NumberFormatException e)
		{
			return null;
		}
	}
	public Short getShort()
	{
		try
		{
			short s = Short.parseShort(value);
			return s;
		}
		catch(NumberFormatException e)
		{
			return null;
		}
	}
	public Float getFloat()
	{
		try
		{
			float f = Float.parseFloat(value);
			return f;
		}
		catch(NumberFormatException e)
		{
			return null;
		}
	}
	public Double getDouble()
	{
		try
		{
			double d = Double.parseDouble(value);
			return d;
		}
		catch(NumberFormatException e)
		{
			return null;
		}
	}
	//is methods
	public boolean isBoolean()
	{
		return getBoolean() != null;
	}
	public boolean isInteger()
	{
		return getInteger() != null;
	}
	public boolean isDouble()
	{
		return getDouble() != null;
	}
	//Methods involving children
	public boolean isLeaf()
	{
		return numChildren() == 0;
	}
	public int numChildren()
	{
		return children.size();
	}
	public boolean hasPath(String path)
	{
		String[] names = path.split("\\.");
		ConfigNode current = this;
		for(String name : names)
		{
			if(!current.hasChild(name))
				return false;
			current = current.getChild(name);
		}
		return true;
	}
	public void addPath(String path)
	{
		String[] names = path.split("\\.");
		ConfigNode current = this;
		for(String name : names)
		{
			if(!current.hasChild(name))
				current.addChild(name);
			current = current.getChild(name);
		}
	}
	public boolean hasChild(String name)
	{
		return children.containsKey(name);
	}
	public boolean hasChildByPath(String path, String name)
	{
		if(hasPath(path))
		{
			return getChildByPath(path).hasChild(name);
		}
		return false;
	}
	public boolean hasChildren()
	{
		return numChildren() > 0;
	}
	public boolean hasChildrenByPath(String path)
	{
		if(hasPath(path))
		{
			return getChildByPath(path).hasChildren();
		}
		return false;
	}
	public ConfigNode getChild(String name)
	{
		return children.get(name);
	}
	public ConfigNode[] getChildren()
	{
		return children.values().toArray(new ConfigNode[children.size()]);
	}
	public ConfigNode getChildByPath(String path)
	{
		String[] names = path.split("\\.");
		ConfigNode current = this;
		for(String name : names)
		{
			if(!current.hasChild(name))
				return null;
			current = current.getChild(name);
		}
		return current;
	}
	public ConfigNode getChildByPath(String path, String name)
	{
		String[] names = path.split("\\.");
		ConfigNode current = this;
		for(String cname : names)
		{
			if(!current.hasChild(cname))
				return null;
			current = current.getChild(cname);
		}
		if(current.hasChild(name))
			return current.getChild(name);
		return null;
	}
	public void addChild(ConfigNode node)
	{
		children.put(node.getName(), node);
	}
	public void addChild(String name)
	{
		addChild(new ConfigNode(name, null));
	}
	public void addChild(String name, String value)
	{
		addChild(new ConfigNode(name, value));
	}
	public void addChildren(ConfigNode[] nodes)
	{
		for(ConfigNode node : nodes)
			children.put(node.getName(), node);
	}
	public void addChildren(String[] names)
	{
		for(String name : names)
			children.put(name, new ConfigNode(name));
	}
	public void addChildByPath(String path, ConfigNode node)
	{
		addPath(path);
		ConfigNode current = getChildByPath(path);
		if(current != null)
			current.addChild(node);
	}
	public void addChildByPath(String path, String name)
	{
		addPath(path);
		ConfigNode current = getChildByPath(path);
		if(current != null)
			current.addChild(name, null);
	}
	public void addChildByPath(String path, String name, String value)
	{
		addPath(path);
		ConfigNode current = getChildByPath(path);
		if(current != null)
			current.addChild(name, value);
	}
	public void removeChild(String name)
	{
		children.remove(name);
	}
	public void removeChildren()
	{
		children.clear();
	}
	public void removeChildren(String[] names)
	{
		for(String name : names)
			children.remove(name);
	}
	public void removeChildByPath(String path, String name)
	{
		ConfigNode current = getChildByPath(path);
		if(current != null && current.hasChild(name))
			current.removeChild(name);
	}
	//Other methods
	public static ConfigNode createRoot()
	{
		return new ConfigNode();
	}
	//File handling
	public static ConfigNode load(String path, String filename) throws IOException
	{
		new File(path).mkdirs();
		BufferedReader IN = new BufferedReader(new FileReader(path+filename));
		String line = "";
		HashMap<Integer, ConfigNode> parents = new HashMap<Integer, ConfigNode>();
		ConfigNode root = createRoot(), current = null;
		parents.put(-1, root);
		while(true)
		{
			line = IN.readLine();
			if(line == null)
				break;
			int indentation = 0;
			for(int i = 0; i < line.length(); i++)
			{
				if(line.charAt(i) == ' ')
					indentation++;
				else
					break;
			}
			indentation /= INDENT;
			String[] lineComponents = line.trim().split(": ");
comment:	{
				if(lineComponents.length > 0)
				{
					if(lineComponents[0].startsWith("#") || lineComponents[0].equals(""))
						break comment;
					if(lineComponents.length == 1)
					{
						current = new ConfigNode(lineComponents[0], null);
					}
					else
					{
						current = new ConfigNode(lineComponents[0], lineComponents[1]);
					}
					parents.put(indentation, current);
					parents.get(indentation-1).addChild(current);
					current = null;
				}
			}
		}
		IN.close();
		return root;
	}
	public static void save(String path, String filename, ConfigNode config) throws IOException
	{
		new File(path).mkdirs();
		BufferedWriter OUT = new BufferedWriter(new FileWriter(path+filename));
		OUT.write(toStringRecursive(config));
		OUT.close();
	}
	//toString methods
	public String toString()
	{
		if(value == null)
			return name;
		else
			return name + ": " + value;
	}
	public String toString(int indentation)
	{
		indentation *= INDENT;
		String str = "";
		for(int i = 0; i < indentation; i++)
		{
			str += ' ';
		}
		return str+toString();
	}
	public String toStringRecursive()
	{
		return toStringRecursive(this, -1);
	}
	public String toStringRecursive(int indentation)
	{
		return toStringRecursive(this, indentation);
	}
	public static String toStringRecursive(ConfigNode config)
	{
		return toStringRecursive(config, -1);
	}
	public static String toStringRecursive(ConfigNode config, int indentation)
	{
		String str = "";
		if(indentation >= 0)
			str = config.toString(indentation) + '\n';
		indentation++;
		for(ConfigNode child : config.getChildren())
		{
			str += toStringRecursive(child, indentation);
		}
		indentation--;
		return str;
	}
}
 

 

ok so that worked beautifully, and i cant believe that i didn't remember that the list itself ISN'T a string so you have to go threw the list and add each string to the ArrayList. now all i need to do is check whether or not a players name is on that list to allow or deny access to something.

I finally got everything to work. Once I added all strings to the arrayList I can compare the player name by using:
If(bannedplayers.contains(sender.getName());

Thanks a lot to everyone who has helped!!!

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

If you are collecting a bunch of strings, and you expect to be checking if the collection contains a given string often, then don't use a list, use a set or a map. This is far more efficient for contain checks, especially if the collection is large or checks are done often.

 

Yea, changing it to a HashSet might be a little faster.

 

I'll look into doing that as soon as a I get a fully working build.