How to turn conditional chaining into faster ugly code?

The standard approach is to use a map to connect the key strings to a lexer that will handle them:

Map<String,Lexer> lexerMap = new HashMap<String,Lexer>();
lexerMap.put("source1", new Lexer01());
lexerMap.put("source2", new Lexer02());
// and so on

      

        
        
        
      

    

Once you get the string that identifies the lexer to use, you should get it from the map like this:

String grammarId = // read it from a file, whatever
Lexer myLexer = lexerMap.get(grammarId);

      

        
        
        
      

    

However, there are a few quirks in your example code. First, the calls to indexOf () indicate that you don't have a separate line and Map won't look inside the line. So you need to somehow extract the actual key from whatever string you read.

Second, lexers and parsers generally maintain state, so you can't create one instance and reuse it. This means you need to create a factory class and store it in the map (this is the Abstract factory pattern).

If you expect to have many different lexers / parsers, then it makes sense to use a map based approach. For a small number, the if-else chaining is probably best suited, properly encapsulated (that's the factory method pattern).

Replace conditional with polymorphism

For half a measure, for findsite (), you can simply tweak the HashMap to get from the site id to the site. An alternative cleanup would be to simply return the site string, thus:

String findsite(txt) {
  ...................
  if line.indexOf("site1-identifier") 
    return site1;
  if(line.indexOf("site2-identifier")
    return  site2;
  if(line.indexOf("site3-identifier")
    return  site3;
...
}

      

        
        
        
      

    

Using indexOf () in this way is not very expressive; I would use equals () or contains ().

I was thinking about outputting the lexer / parser replicator in sep. classes and then creating them as soon as I get a match

It looks like you already have an answer. This would create more flexible, but not necessary faster code.

I assume some benchmarking is ok

Yes, measure both approaches and make an informed decision. My guess is how you've had enough of it already.

Maybe if you need kilometric you can refactor it in different functions using the extract method .

The most important thing is to first create a solution that gets the job done, even if it is slow, and once you get it working, analyze it and identify the points at which performance can be improved. Remember the "Optimization Rules"

Let's assume your code is inefficient.

Will it take longer than (say) 1% of the time to actually parse the input?

If not, you have a great "fish to fry".

I would change the type of findsite to return the site type (superclass) and then use polymorphism ... This should be faster than string manipulation ...

Need separate lexers?

Use the sitemap to customize your site to load your strategy structure. Then a simple search based on "site" is required and you follow the appropriate strategy. The same can be done for findSite ().

Can have an ids map against sites and then just iterate over the map entries.

// define this as a static somewhere ... build from a properties file
Map<String,String> m = new HashMap<String,String>(){{
    put("site1-identifier","site2");
    put("site2-identifier","site2");
}}

// in your method
for(Map.Entry<String,String> entry : m.entries()){
    if( line.contains(entry.getKey())){
        return line.getValue();
    }
}

      

        
        
        
      

    

cleaner: yes faster: dunno ... should be fast enough

Can use reflection maybe

char site = line.charAt(4);
Method lexerMethod = this.getClass().getMethod( "loadLexer" + site, *parameters types here*)
Method parserMethod = this.getClass().getMethod( "loadparser" + site, *parameters types here*)

lexerMethod.invoke(this, *parameters here*);
parserMethod.invoke(this, *parameters here*);