Need a little help with RAF logic

Question

So Im making a program to give different users, different rights. This is the method that appends them to file and Map
     * Writes the players rights to the appendages
     * @param playerName Player to update
     * @param playerRights Rights to give the player
     * @param pointer The lines index in the files
     * @throws IOException If a read/write error occours
    public void writeRights(String playerName, Rights playerRights, long pointer) throws IOException {
        rightsRAF.seek(pointer);
        rightsRAF.write(("\n" + playerName + "::" + playerRights).getBytes());
        if(rightsRAF.read() != '\n') {
            rightsRAF.seek(rightsRAF.getFilePointer()-1);
            rightsRAF.write("\n".getBytes());
        rightsMap.put(playerName, playerRights);
    }1. The RAF goes to the predetermined index in the file, pointer, which is the line the users name starts on. Entries are stored in the file as "name::RIGHTS"
2.It writes out the players name, and rights
3. It checks to see if it accidentally wrote over the \n
My problem now, is that some rights are longer than others. For example, if there was already an entry, "name::MODERATOR" and you overwrite it, with "name::OWNER" then it would turn into "name::OWNERATOR" because the rest of the line wasn't overwritten.
I need some help with logic to determine how to overwrote the entire line, because sometimes you could go from a short one, to a long one, and need to append a new \n character, and sometimes you could go the other way around from long to short and end up with two words fused, I cant figure out how to determine whats a word that got partially overwritten and whats a new line totally.
Thanks

Answer 1

As pointed out you need to have fixed size records, or at least a maximum size.
You also have another problem nobody commented on yet (I don't think) with the getBytes() calls. At that point in your code you will mangle most unicode Strings.
All things being equal here I think your best solution is to use an embedded database like JavaDB with JDBC. I think you will find an XML solution to slow for your purposes.
If you decide to continue the RAF route though here is an example. I know this is not exactly what you are doing but you can extrapolate from this...
public void updatePlayerName(String playerName, int playerIndex){
   int recordlength = 200;  
   byte[] buff = playerName.getBytes("UTF-8");
   if(buff.length>recordlength){
      //truncate bytes. this is also not great because a character at the end could be mangled
      byte[] temp = new byte[recordlength];
      System.arraycopy(buff,0,temp,0,temp.length);
      buff = temp;
   long pointer = playerIndex * (recordlength+4);// plus 4 bytes per record for actual length
   raf.seek(pointer);
   raf.writeInt(buff.length);
   raf.write(buff);
public String getPlayerName(int playerindex){
    int recordlength = 200;  
    long pointer = playerIndex * (recordlength+4);
    raf.seek(pointer);
    int lengthToRead = raf.readInt();
    //length to read should be checked for sanity or bad things will happen next
    byte[] buff = new byte[lengthToRead];
    raf. readFully(buff);
    return new String(buff,"UTF-8");
}And then of course you'd have to add storing the "rights". It gets complicated in a hurry. I do really recommend the JDBC route.