Parse a line from a text file and access the value inside of the parentheses

Question

So i'm parsing a line from text file and getting a string like:

color(black)

or

color(RGB(142,0,0))

So I wrote a code:

private Sprite makeSpriteToBackGround(String line) {
        if (line.contains("color")) {
            ColorsParser colorsParser = new ColorsParser();
            Color color = colorsParser.colorFromString(line.substring(line.indexOf("RGB")));
            return new Sprite() {
                @Override
                public void drawOn(DrawSurface d) {
                    d.setColor(color);
                    d.fillRectangle(0, 0, 800, 600);
                }

                @Override
                public void timePassed() {
                }
            };
}

So my goal is to check whether the line contains "RGB" or not. If it does - it will be parsed through my colorFromString parser function, and if not, it will just will be deployed as the color.

How would you suggest me to parse the

color(black)

part?

because the RGB part works perfectlly.

Answer 1

You probably want to check for the presence of RGB first, and then fallback to looking for known values in a lookup table.

Map<String, Color> colors = new HashMap<String, Color>() {{
    put("black", Color.BLACK);
    put("red", Color.RED);
    put("green", Color.GREEN);
    put("blue", Color.BLUE);
}};

Color color = null;
int rgbIndex = line.indexOf("RGB");
if (rgbIndex > -1) {
    color = colorsParser.colorFromString(line.substring(rgbIndex));
} else {
    // There are better ways to extract text between brackets, see https://stackoverflow.com/questions/24256478/pattern-to-extract-text-between-parenthesis/24256532
    String colorName = line.substring(line.indexOf("(") + 1, line.indexOf(")"));
    color = colors.get(colorName);
}

// TODO: Make sure you check if `color` is null here.

Answer 2

public class TestColor {

    public static void main(String[] args) {
        String fullColorStr = "color(yellow)";
        
        //Precondition
        if (fullColorStr == null || fullColorStr.trim().isEmpty()) {
            throw new IllegalArgumentException("Color cannot be empty");
        }
        
        String colorStr = fullColorStr.substring(fullColorStr.indexOf("(")+1,fullColorStr.indexOf(")"));
        Color color = getColorFromString(colorStr);
        System.out.print(color);
    }

    private static Color getColorFromString(String colorStr) {
        //Precondition
        if (colorStr == null || colorStr.trim().isEmpty()) {
            return null;
        }

        Color color = null;
        String lowerColorStr = colorStr.toLowerCase();
        try {
            Field colorField = Color.class.getField(lowerColorStr);
            //Paranoid check start
            Class<?> type = colorField.getType();
            if (type != Color.class) {
                throw new IllegalStateException("Shoudln't have encountered this : " + colorStr);
            } //End 
            color = (Color) colorField.get(Color.class);
        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
            throw new IllegalArgumentException("Not a valid color : " + colorStr);
        }
        return color;
    }

}

Answer 3

I wonder why none of the other commenters has already mentioned it, but there is an established way to solve this class of problems: Regular Expressions

You described two patterns:

• the named pattern: color\((\w+)\) (see live on regex101.com)
• the RGB pattern: color\(RGB\((\d+)\,(\d+)\,(\d+)\)\) (see live on regex101.com)

Many deveolpers are afraid of Regular Expressions, but they are extremely helpful here. All you have to do in your code, is to pick the values from the matches:

package color;

import java.awt.Color;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ColorParser {

    private final Pattern namedPattern = Pattern.compile("color\\((\\w+)\\)");
    private final Pattern rgbPattern = Pattern.compile("color\\(RGB\\((\\d+)\\,(\\d+)\\,(\\d+)\\)\\)");

    public Color parse(String line) {
        Color result = parseRGB(line);
        if (result == null) {
            result = parseNamed(line);
        }
        return result;
    }

    private Color parseRGB(String line) {
        final Matcher matcher = rgbPattern.matcher(line);
        if (matcher.find()) {
            final int red = Integer.parseInt(matcher.group(1));
            final int green = Integer.parseInt(matcher.group(2));
            final int blue = Integer.parseInt(matcher.group(3));
            return new Color(red, green, blue);
        }
        return null;
    }

    private Color parseNamed(String line) {
        final Matcher matcher = namedPattern.matcher(line);
        if (matcher.find()) {
            final String name = matcher.group(1);
            try {
                // java.awt.Color is not an enum, so let's use Reflection
                return (Color) Color.class.getField(name.toUpperCase()).get(null);
            } catch (Exception e) {
                // ignore
            }
        }
        return null;
    }
}

Here is a JUnit test to verify it:

package color;

import static org.junit.Assert.assertEquals;

import java.awt.Color;

import org.junit.Test;

public class ColorParserTest {

    final ColorParser sut = new ColorParser();

    @Test
    public void testParse_Named() {
        assertEquals(Color.BLACK, sut.parse("color(black)"));
    }

    @Test
    public void testParse_NamedInText() {
        assertEquals(Color.RED, sut.parse("foo color(Red) bar"));
    }

    @Test
    public void testParse_RGB() {
        assertEquals(Color.ORANGE, sut.parse("color(RGB(255,200,0))"));
    }

    @Test
    public void testParse_Unkown() {
        assertEquals(null, sut.parse("color(foo)"));
    }
}

I used the AWT Color class here. Depending on your use case you might need a mapping table to resolve other named colors, like HTML colors or X11 colors.