ProductionRuleTokenParser


1   package com.daffodilwoods.daffodildb.utils.parser;
2   
3   import java.util.ArrayList  ;
4   import java.util.Comparator  ;
5   import java.util.HashMap  ;
6   import java.util.Arrays  ;
7   import java.util.List  ;
8   import com.daffodilwoods.database.utility.P;
9   import com.daffodilwoods.daffodildb.utils.DBStack;
10  import com.daffodilwoods.database.resource.DException;
11  import java.util.*;
12  
13  /**
14   * A ProductionRuleTokenParser Class extending ProductionRuleParser.
15   * This class provides us many functionalities.
16   * In this class, we make TokenProductionRules by scanning all the rules hierarachy.
17   * For this at first step we call for <token> rule through productionruleparser, Through
18   * this we are able to have a hashmap TokenRules containing all the token rules.
19   * At the second step we go for making TokenProductionRules.
20   * In this class , we ask for RecursiveObjects and NonRecursiveObjects for each rule.
21   * In this class , we determine rules with two parents and store them to file withHashMapRules.
22   */
23  
24  public class ProductionRuleTokenParser extends ProductionRuleParser implements ProductionRuleParserConstants{
25  
26     /**
27      * HashMap tokenRules is held to make TokenProductionRules. It contains the entry of all the Tokens Rule.
28      */
29     HashMap     tokenRules ;
30  
31     /**
32      * Vector for Comparable Rules to be added in nonComparable.
33      */
34     List   comparableToNonComparable;
35  
36     public ProductionRuleTokenParser(java.net.URL   urlPath,ClassLoader   classLoader0) throws DException{
37        super(urlPath,classLoader0);
38     }
39  
40     public ProductionRuleTokenParser(ClassLoader   classLoader0) throws DException{
41        super(classLoader0);
42     }
43  
44     /**
45      * This method is used to make TokenProductionRules for all Rules which are tokens.
46      * This method is also used to getComparableObjects for OrRules.
47      */
48  
49     private void getProductionRuleSupportingTokens(ProductionRules productionRules){
50        if(productionRules instanceof StringProductionRules)
51           return;
52        String   name = productionRules.ruleKey;
53        if ( name == null ){
54           productionRules.ruleKey = productionRules.nameOfRule;
55           name = productionRules.ruleKey;
56        }
57        if ( recursion.contains(name) ){
58           if (!(productionRules instanceof OrProductionRules || productionRules instanceof OrProductionRulesWithHashMap) )
59              assiningTokens(productionRules.rules);
60           return;
61        }
62        if ( productionRules instanceof OrProductionRules ){
63           recursion.add(name);
64           OrProductionRules orRule = (OrProductionRules)productionRules;
65           callRecursively(orRule.recursiveObjects);
66           callRecursively(orRule.nonRecursiveObjects);
67           callRecursively(orRule.comparableRules);
68           getComparableObjects((OrProductionRules)productionRules);
69        }else if ( productionRules instanceof OrProductionRulesWithHashMap ){
70           recursion.add(name);
71           OrProductionRulesWithHashMap orRule = (OrProductionRulesWithHashMap)productionRules;
72           callRecursively(orRule.recursiveObjects);
73           callRecursively(orRule.nonRecursiveObjects);
74           callRecursively(orRule.comparableRules);
75           getComparableObjects((OrProductionRulesWithHashMap)productionRules);
76        }
77        else{
78           recursion.add(name);
79           callRecursively(productionRules.rules);
80        }
81     }
82     /**
83      * This Method is used for Assigning Tokens for Rules in Union and other rules other than
84      * OrRules.
85      */
86     private void assiningTokens(Object   [] listOfRules){
87        if ( listOfRules == null )
88           return;
89        for(int i = 0; i < listOfRules.length; ++i){
90           ProductionRules productionRule = (ProductionRules)listOfRules[i];
91           if ( tokenRules.containsKey(productionRule.nameOfRule) ){
92              String   nameOfClass = productionRule.initailizeNameOfClass(productionRule.nameOfRule);
93              String   name = nameOfClass.substring(nameOfClass.lastIndexOf(".")+1);
94              TokenProductionRule rule = null;//new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader);
95              if ( productionRule.nameOfRule.equalsIgnoreCase(REGULARIDENTIFIER) ){
96                 rule = new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader,3);
97              }else if ( productionRule.nameOfRule.equalsIgnoreCase(DELIMITEDIDENTIFIER) ){
98                 rule = new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader,4);
99              }else{
100                rule = new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader,0);
101             }
102             if ( productionRule.result instanceof String  [] )
103                rule.result = productionRule.nameOfRule;
104             else
105                rule.result = new String  []{(String  )productionRule.nameOfRule};
106             listOfRules[i] = rule;
107          }
108       }
109    }
110 
111    /**
112     * This method is used to make TokenProductionRule whose rule is having an entry in an
113     * hashmap of tokenRules.
114     */
115    private void callRecursively(Object   []listOfRules){
116       if ( listOfRules == null )
117          return;
118       for(int i = listOfRules.length - 1 ; i >= 0 ; --i){
119          ProductionRules productionRule = (ProductionRules)listOfRules[i];
120          if ( tokenRules.containsKey(productionRule.nameOfRule) ){
121             String   nameOfClass = productionRule.initailizeNameOfClass(productionRule.nameOfRule);
122             String   name = nameOfClass.substring(nameOfClass.lastIndexOf(".")+1);
123             TokenProductionRule rule = null;//new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader);
124             if ( productionRule.nameOfRule.equalsIgnoreCase(REGULARIDENTIFIER) ){
125                rule = new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader,3);
126             } else if ( productionRule.nameOfRule.equalsIgnoreCase(DELIMITEDIDENTIFIER)){
127                rule = new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader,4);
128             }else{
129                rule = new TokenProductionRule(nameOfClass,name,name.toCharArray(),classLoader,0);
130             }
131             if ( productionRule.result instanceof String  [] )
132                rule.result = productionRule.nameOfRule;
133             else
134                rule.result = new String  []{(String  )productionRule.nameOfRule};
135             listOfRules[i] = rule;
136          }
137          else
138             getProductionRuleSupportingTokens(productionRule);
139       }
140    }
141 
142    /**
143     * This method is used to get RecursiveObjects for a productionRule passed.
144     * IN this class , commented portion is used to determine rules with multiple parents.
145     */
146    public void getRecursiveObjects(ProductionRules production){
147       String   ruleName = production.ruleKey;
148       if ( production instanceof StringProductionRules )
149          return;
150       if ( recursion.contains(ruleName) )
151          return;
152       recursion.add(ruleName);
153       DBStack occuredRules = new DBStack();
154       Object  [] rls = production.rules;
155       if ( rls == null )
156          return;
157       int size = rls.length;
158       occuredRules.push(ruleName);
159       ArrayList   rec     = new ArrayList  (25);
160       ArrayList   nonrec  = new ArrayList  (25);
161       Comparator   cmpg = new RuleComparator();
162       TreeMap recMap = new TreeMap(cmpg);
163       TreeMap nonrecMap = new TreeMap(cmpg);
164       for(int i = 0; i < size; ++i){
165          ProductionRules productionRule = (ProductionRules)rls[i];
166          if ( production instanceof OrProductionRules )
167             getRecursiveForRule((OrProductionRules)production,occuredRules,productionRule,ruleName,rec,nonrec,recMap,nonrecMap);
168          if ( production instanceof OrProductionRulesWithHashMap )
169             getRecursiveForRule((OrProductionRulesWithHashMap)production,occuredRules,productionRule,ruleName,rec,nonrec,recMap,nonrecMap);
170          getRecursiveObjects(productionRule);
171       }
172       if ( production instanceof OrProductionRules ){
173          ((OrProductionRules)production).recursiveObjects  = rec.toArray();
174          ((OrProductionRules)production).nonRecursiveObjects  = nonrec.toArray();
175       }
176       if ( production instanceof OrProductionRulesWithHashMap ){
177          ((OrProductionRulesWithHashMap)production).nonRecursiveObjects  = nonrec.toArray();
178          ((OrProductionRulesWithHashMap)production).recursiveObjects  = rec.toArray();
179       }
180    }
181 
182    /**
183     * This method is used for getting Comparable Objects For OrPRoductionRulesWithHashMap
184     */
185    private void getComparableObjects(OrProductionRulesWithHashMap or){
186       ArrayList   arr = new ArrayList  (); // non Comparable Rules
187       ArrayList   comparable = new ArrayList  (); // comparable Rules
188       if(or.nonRecursiveObjects == null)
189          return;
190       for(int i = 0 ; i < or.nonRecursiveObjects.length ; i++){
191          ProductionRules pq = (ProductionRules)or.nonRecursiveObjects[i];
192          if ( !withHashMapWithBinary.contains(pq.ruleKey) )
193             if ( pq instanceof OrProductionRulesWithHashMap || pq instanceof UnionProductionRulesWithHashMap
194          || pq instanceof SimpleProductionRulesWithHashMap || pq instanceof RepetitiveProductionRulesWithHashMap
195          || comparableToNonComparable.contains(pq.ruleKey) ){
196                arr.add(pq);
197                continue;
198             }
199             if(pq.getComparableObjectArray()!= null )
200                comparable.add(pq);
201             else
202                arr.add(pq);
203       }
204       or.nonRecursiveObjects = arr.toArray();
205       if(!comparable.isEmpty()){
206          if ( or.comparableRules != null && or.comparableRules.length > 0 )
207             for(int i = 0; i < or.comparableRules.length; ++i){
208          if ( !comparable.contains(or.comparableRules[i]) )
209             comparable.add(or.comparableRules[i]);
210             }
211             sortComparableRules(comparable,or);
212             or.comparableRules = comparable.toArray();
213       }
214    }
215 
216    /**
217     * This method is used for getting Comparable Objects For OrProductionRules
218     */
219 
220    private void getComparableObjects(OrProductionRules or){
221       ArrayList   arr = new ArrayList  (); // non Comparable Rules
222       ArrayList   comparable = new ArrayList  (); // comparable Rules
223       if ( or.nonRecursiveObjects == null ) return;
224       for(int i = 0 ; i < or.nonRecursiveObjects.length ; i++){
225          ProductionRules pq = (ProductionRules)or.nonRecursiveObjects[i];
226          if ( !withHashMapWithBinary.contains(pq.ruleKey) )
227             if ( pq instanceof OrProductionRulesWithHashMap || pq instanceof UnionProductionRulesWithHashMap
228          || pq instanceof SimpleProductionRulesWithHashMap || pq instanceof RepetitiveProductionRulesWithHashMap
229          || comparableToNonComparable.contains(pq.ruleKey) ){
230                arr.add(pq);
231                continue;
232             }
233             if(pq.getComparableObjectArray()!= null )
234                comparable.add(pq);
235             else
236                arr.add(pq);
237       }
238       or.nonRecursiveObjects = arr.toArray();
239       if(!comparable.isEmpty()){
240          if ( or.comparableRules != null && or.comparableRules.length > 0 )
241             for(int i = 0; i < or.comparableRules.length; ++i){
242          if ( !comparable.contains(or.comparableRules[i]) )
243             comparable.add(0,or.comparableRules[i]);
244             }
245             sortComparableRules(comparable,or);
246             or.comparableRules = comparable.toArray();
247       }
248    }
249 
250    /**
251     * This method is used for sorting Comparable Rules.
252     */
253    private void sortComparableRules(ArrayList   listOfComparableRules,ProductionRules rule){
254       Object   array[] = listOfComparableRules.toArray();
255       Arrays.sort(array,new StringComparatorForSql());
256       listOfComparableRules.clear();
257       listOfComparableRules.addAll(Arrays.asList(array));
258    }
259 
260    /**
261     * This method is used to add recursive and nonrecursiveObjects to an OrProductionRules
262     */
263 
264    private void getRecursiveForRule(OrProductionRules orRule,DBStack occuredRules,
265                                     ProductionRules productionRule,String   ruleName,
266                                     ArrayList   recursiveObjects,ArrayList   nonRecursiveObjects,
267                                     Map   recMap, Map   nonrecMap)
268    {
269       occuredRules.clear();
270       occuredRules.add(ruleName);
271       Object   []object = (Object   [])productionRule.getRecursiveObject(ruleName,occuredRules);
272       occuredRules.clear();
273       occuredRules.add(ruleName);
274       Object   []object1 = (Object   [])productionRule.getNonRecursiveObject(ruleName,occuredRules);
275       if ( object != null ){
276          for(int k = 0; k < object.length; ++k){
277             if (! recMap.containsKey(object[k]) ){
278                recursiveObjects.add(object[k]);
279                recMap.put(object[k],null);
280             }
281          }
282       }
283       if ( object1 != null ){
284          for(int k = 0; k < object1.length; ++k){
285             if (! nonrecMap.containsKey(object1[k]) ){
286                nonRecursiveObjects.add(object1[k]);
287                nonrecMap.put(object1[k],null);
288             }
289          }
290       }
291    }
292 
293    /**
294     * This method is used to add recursive and nonrecursiveObjects to an OrProductionRulesWithHashMap
295     */
296 
297    private void getRecursiveForRule(OrProductionRulesWithHashMap orRule,DBStack
298                                     occuredRules,ProductionRules productionRule,
299                                     String   ruleName,ArrayList   recursiveObjects,
300                                     ArrayList   nonRecursiveObjects,
301                                     Map   recMap, Map   nonrecMap
302                                     ){
303       occuredRules.clear();
304       occuredRules.add(ruleName);
305       Object   []object = (Object   [])productionRule.getRecursiveObject(ruleName,occuredRules);
306       occuredRules.clear();
307       occuredRules.add(ruleName);
308       Object   []object1 = (Object   [])productionRule.getNonRecursiveObject(ruleName,occuredRules);
309       if ( object != null ){
310          for(int k = 0; k < object.length; ++k)
311             if (! recMap.containsKey(object[k]) ){
312                recursiveObjects.add(object[k]);
313                recMap.put(object[k],null);
314             }
315       }
316       if ( object1 != null ){
317          for(int k = 0; k < object1.length; ++k){
318             if (! nonrecMap.containsKey(object1[k]) ){
319                nonRecursiveObjects.add(object1[k]);
320                nonrecMap.put(object1[k],null);
321             }
322          }
323       }
324    }
325 
326    /**
327     * This method is used for getting ComparableRules for an productionRules object passed.
328     */
329    private void getComparableObjectsForToken(ProductionRules productionRules){
330       if(productionRules instanceof StringProductionRules)
331          return;
332       String   name = productionRules.ruleKey;
333       Object   []rules = productionRules.rules;
334       if (rules == null)
335          return;
336       testingForDigit(name,productionRules);
337       if ( recursion.contains(name) && !recursion.contains(IDENTIFIERPART) )
338          return;
339       recursion.add(name);
340       for(int i = 0; i < rules.length; ++i){
341          ProductionRules rule = (ProductionRules)rules[i];
342          if ( productionRules instanceof OrProductionRules )
343             getComparableObjectsToken((OrProductionRules)productionRules);
344          if ( productionRules instanceof OrProductionRulesWithHashMap )
345             getComparableObjectsToken((OrProductionRulesWithHashMap)productionRules);
346          getComparableObjectsForToken(rule);
347       }
348    }
349 
350    /**
351     * This method is used for getting ComparableObjects for OrProductionRulesWithHashMap
352     */
353    private void getComparableObjectsToken(OrProductionRulesWithHashMap or){
354       ArrayList   arr = new ArrayList  ();
355       ArrayList   comparable = new ArrayList  ();
356       for(int i = 0 ; i < or.nonRecursiveObjects.length ; i++){
357          ProductionRules pq = (ProductionRules)or.nonRecursiveObjects[i];
358          if(pq.getComparableObject()!= null )
359             comparable.add(pq);
360          else{
361             makeDummyRule(comparable,arr);
362             arr.add(pq);
363          }
364       }
365       if ( ! comparable.isEmpty() )
366          makeDummyRule(comparable,arr);
367       or.nonRecursiveObjects = arr.toArray();
368    }
369 
370    /**
371     * This method is used for getting ComparableObjects for OrProductionRules.
372     */
373    private void getComparableObjectsToken(OrProductionRules or){
374       ArrayList   arr = new ArrayList  ();
375       ArrayList   comparable = new ArrayList  ();
376       for(int i = 0 ; i < or.nonRecursiveObjects.length ; i++){
377          ProductionRules pq = (ProductionRules)or.nonRecursiveObjects[i];
378          if(pq.getComparableObject()!= null )
379             comparable.add(pq);
380          else{
381             makeDummyRule(comparable,arr);
382             arr.add(pq);
383          }
384       }
385       if ( ! comparable.isEmpty() )
386          makeDummyRule(comparable,arr);
387       or.nonRecursiveObjects = arr.toArray();
388    }
389 
390    private void makeDummyRule(ArrayList   comparable,ArrayList   nonRecursiveObjects){
391       if ( comparable.isEmpty() )
392          return;
393       String   ruleName = DummyNameGetter.getNameOfOrProductionRule();
394       OrProductionRules orRule = new OrProductionRules(classLoader);
395       orRule.nameOfRule = ruleName;
396       orRule.ruleKey  = ruleName;
397       sortComparableRulesToken(comparable);
398       orRule.comparableRules = comparable.toArray();
399       nonRecursiveObjects.add(orRule);
400       comparable.clear();
401    }
402 
403    /**
404     * This method is used for sorting ComparableRules passed.
405     */
406 
407    private void sortComparableRulesToken(ArrayList   listOfComparableRules){
408       Object   array[] = listOfComparableRules.toArray();
409       Arrays.sort(array);
410       listOfComparableRules.clear();
411       listOfComparableRules.addAll(Arrays.asList(array));
412    }
413 
414    private void testingForDigit(String   name,ProductionRules productionRules){
415       if ( name.equalsIgnoreCase(DIGIT) ){
416          Arrays.sort(productionRules.rules);
417          ((OrProductionRulesWithHashMap)productionRules).comparableRules = productionRules.rules;
418       }
419    }
420 
421     /**
422      * This method is very usefull :
423      *   Making ProductionRules for Token rule
424      *   Making ProductionRules for ruleName passed
425      *   For Getting Recursive and NonrecursiveObjects for all ProductionRules
426      *   For Making TokenProductionRules
427      */
428 
429     public ProductionRules getProductionRule1(String   productionRuleName)throws DException{
430      recursion.clear();
431       ProductionRuleParser  productionRuleparser = null;
432       if ( url == null )
433         productionRuleparser  = new ProductionRuleParser(classLoader);
434        else
435         productionRuleparser  = new ProductionRuleParser(url,classLoader);
436       productionRuleparser.withHashMapWithBinary = vectorForBestAndNonBest.getRulesWithComparableWithHashMap();
437       productionRuleparser.tokenFlag   =  true;
438       ProductionRules tokenRule = productionRuleparser.getProductionRule(TOKEN);
439       tokenRules = productionRuleparser.allRules; // global in this class
440       withHashMapWithBinary = vectorForBestAndNonBest.getRulesWithComparableWithHashMap();
441       ProductionRules productionRules  = super.getProductionRule(productionRuleName);
442       getRecursiveObjects(productionRules); // AlongWith hashMap Rules
443       recursion.clear();
444       getRecursiveObjects(tokenRule); // Asking For Token RecursiveObjects.
445       recursion.clear();
446       getComparableObjectsForToken(tokenRule);
447       productionRules.hashMap = vectorForBestAndNonBest.getRulesWithBest();
448       tokenRule.hashMap = productionRules.hashMap;
449       productionRules.tokenRule = tokenRule; // global in productionRules
450       comparableToNonComparable = vectorForBestAndNonBest.getRulesToBeIncludedInNonComparableRules();
451       recursion.clear();
452       getProductionRuleSupportingTokens(productionRules); // AlongWith ComparableRules
453       return productionRules;
454    }
455 
456    /**
457     * This method is used to write rules with multiple parents to a file withHashMapRules.
458     */
459    /*private void writeToFile(){
460       try{
461          FileOutputStream fileOutput = new FileOutputStream("c:\\hashFile");
462          ObjectOutputStream oout = new ObjectOutputStream(fileOutput);
463          oout.writeObject((Object)withHashMapRules);
464          oout.close();
465       }catch(Exception e){
466          e.printStackTrace();
467       }
468    }*/
469 
470   /**
471    * This method is used to print recursive and nonrecursiveObjects for an OrProductionRules
472    */
473   /*private void printOrProductionRules(OrProductionRules orRule){
474      for(int i = 0; i < orRule.rules.length; ++i)
475         P.pln(" OBJECT IN RULES ::  "+orRule.rules[i]);
476 
477      if ( orRule.nonRecursiveObjects != null && ! (orRule.nonRecursiveObjects.length == 0) ){
478         P.pln(" RULE NAME IS : " + orRule.nameOfRule+ "   NONRECURSIVE OBJECTS IS : ");
479         for(int i = 0; i < orRule.nonRecursiveObjects.length; ++i)
480            P.pln(" OBJECT IS ::  "+orRule.nonRecursiveObjects[i]);
481      }
482   }*/
483 
484   /**
485    * This method is used to print recursive and nonrecursiveObjects for an OrProductionRulesWithHashMap
486    */
487   /*private void printOrProductionRules(OrProductionRulesWithHashMap orRule){
488      for(int i = 0; i < orRule.rules.length; ++i)
489         P.pln(" OBJECT IN RULES ::  "+orRule.rules[i]);
490      if ( orRule.nonRecursiveObjects != null && ! (orRule.nonRecursiveObjects.length == 0) ){
491         P.pln(" RULE NAME IS : " + orRule.nameOfRule+ "   NONRECURSIVE OBJECTS IS : ");
492         for(int i = 0; i < orRule.nonRecursiveObjects.length; ++i)
493            P.pln(" OBJECT IS ::  "+orRule.nonRecursiveObjects[i]);
494      }
495   }*/
496 
497  /**
498   * This method is used for deciding which rules have two parents.
499   */
500 
501  /*public void decidingHashMapRules(ProductionRules production){
502     String ruleName = production.ruleKey;
503     if ( production instanceof StringProductionRules )
504        return;
505     if ( recursion.contains(ruleName) ){
506        return;
507     }
508     recursion.add(ruleName);
509     Object []rls = null;
510     if ( production instanceof OrProductionRules ){
511        rls = ((OrProductionRules)production).nonRecursiveObjects;
512        callingdecidingHashMapRules(rls);
513        rls = ((OrProductionRules)production).recursiveObjects;
514        callingdecidingHashMapRules(rls);
515     }
516     else{
517        rls = production.rules;
518        callingdecidingHashMapRules(rls);
519     }
520  }*/
521 
522  /**
523   * This method is used for calling recursively the decidingHashMap function
524   */
525  /*private void callingdecidingHashMapRules(Object []rls){
526     if ( rls == null )
527        return;
528     int size = rls.length;
529     for(int i = 0; i < size; ++i){
530        ProductionRules productionRule = (ProductionRules)rls[i];
531        decidingHashMapRules(productionRule);
532     }
533  }*/
534 
535 /*   private void  decidingBestAndNonBestRules(ProductionRules production,HashMap hashMapWithBestAndNonBestRules){
536       String ruleName = production.ruleKey;
537       if ( production instanceof StringProductionRules )
538          return;
539       if ( recursion.contains(ruleName) )
540          return;
541       Object []rls = production.rules;
542       if ( rls == null ) return;
543       recursion.add(ruleName);
544       for(int i = 0; i < rls.length; ++i){
545         ProductionRules rule = (ProductionRules)rls[i];
546         if ( recursion.contains(rule.ruleKey) ) continue;
547         if ( rule instanceof OrProductionRules )
548             callingBestAndNonBestFunction((OrProductionRules)rule,hashMapWithBestAndNonBestRules);
549         if ( rule instanceof OrProductionRulesWithHashMap )
550             callingBestAndNonBestFunction((OrProductionRulesWithHashMap)rule,hashMapWithBestAndNonBestRules);
551         else
552             decidingBestAndNonBestRules(rule,hashMapWithBestAndNonBestRules);
553       }
554    }
555 
556     private void callingBestAndNonBestFunction(OrProductionRules orRule,HashMap hashMap){
557        Object []objectArray = (Object [])hashMap.get(orRule.nameOfRule);
558        if ( orRule.nameOfRule.equalsIgnoreCase("select sublist") ){
559          Object []nonRecursiveObjects = orRule.nonRecursiveObjects;
560          Object []comparable = orRule.comparableRules;
561          ArrayList withBest =  (ArrayList)objectArray[0];
562          ArrayList withoutBest = (ArrayList)objectArray[1];
563          if ( withBest.contains(ALL) )
564             orRule.nonRecWithBest = nonRecursiveObjects;
565          else if ( withoutBest.contains(ALL) )
566             orRule.nonRecWithoutBest = nonRecursiveObjects;
567          else
568             assigningBestAndNonBest(withBest,withoutBest,nonRecursiveObjects,comparable,orRule);
569        }
570        decidingBestAndNonBestRules(orRule,hashMap);
571     }
572 
573 
574     private void callingBestAndNonBestFunction(OrProductionRulesWithHashMap orRule,HashMap hashMap){
575        Object []objectArray = (Object [])hashMap.get(orRule.nameOfRule);
576        if ( orRule.nameOfRule.equalsIgnoreCase("select sublist") ){
577          Object []nonRecursiveObjects = orRule.nonRecursiveObjects;
578          Object []comparable = orRule.comparableRules;
579          ArrayList withBest =  (ArrayList)objectArray[0];
580          ArrayList withoutBest = (ArrayList)objectArray[1];
581          if ( withBest.contains(ALL) )
582             orRule.nonRecWithBest = nonRecursiveObjects;
583          else if ( withoutBest.contains(ALL) )
584             orRule.nonRecWithoutBest = nonRecursiveObjects;
585          else
586             assigningBestAndNonBest(withBest,withoutBest,nonRecursiveObjects,comparable,orRule);
587        }
588        decidingBestAndNonBestRules(orRule,hashMap);
589     }
590 
591     private void assigningBestAndNonBest(ArrayList withBest,ArrayList withoutBest,Object []nonRecursiveObjects,Object []comparable,OrProductionRules orRule){
592       checkingForNonRecAndComparable(comparable,withBest,withoutBest);
593       checkingForNonRecAndComparable(nonRecursiveObjects,withBest,withoutBest);
594       orRule.nonRecWithBest = withBest.toArray();
595       orRule.nonRecWithoutBest = withoutBest.toArray();
596     }
597 
598     private void assigningBestAndNonBest(ArrayList withBest,ArrayList withoutBest,Object []nonRecursiveObjects,Object []comparable ,OrProductionRulesWithHashMap orRule){
599       checkingForNonRecAndComparable(comparable,withBest,withoutBest);
600       checkingForNonRecAndComparable(nonRecursiveObjects,withBest,withoutBest);
601       orRule.nonRecWithBest = withBest.toArray();
602       orRule.nonRecWithoutBest = withoutBest.toArray();
603     }
604 
605     private void checkingForNonRecAndComparable(Object []objects,ArrayList withBest,ArrayList withoutBest){
606       for(int i = 0; i < objects.length; ++i){
607         ProductionRules rule = (ProductionRules)objects[i];
608         withBest = checkingForBestRule(withBest,rule);
609         withoutBest = checkingForWithoutBestRule(withoutBest,rule);
610       }
611     }
612 
613     private ArrayList checkingForBestRule(ArrayList withBest,ProductionRules rule){
614       if ( withBest.contains(rule.nameOfRule) ){
615         withBest.add(rule);
616         withBest.remove(rule.nameOfRule);
617       }
618       return withBest;
619     }
620 
621     private ArrayList checkingForWithoutBestRule(ArrayList withoutBest,ProductionRules rule){
622       if ( withoutBest.contains(rule.nameOfRule) ){
623         withoutBest.add(rule);
624         withoutBest.remove(rule.nameOfRule);
625       }
626       return withoutBest;
627     }*/
628 
629    /*private void getComparableObjectsForOtherRules(ProductionRules rule){
630       Object []rules = rule.rules;
631       for(int i = 0; i < rules.length; ++i){
632          ProductionRules production = (ProductionRules)rules[i];
633          getComparableObjectsForToken(production);
634       }
635    }*/
636 
637 }
638 
639 class StringComparatorForSql implements Comparator  {
640 
641    StringComparatorForSql(){
642    }
643 
644    public int compare(Object   source,Object   target){
645       ProductionRules object1 = (ProductionRules)source;
646       ProductionRules object2 = (ProductionRules)target;
647       if ( object1.result == null ){
648          if ( object2.result == null )
649             return 0;
650          return -1;
651       }else if ( object2.result == null )
652          return 1;
653       String   []source1 = null;
654       String   []target1 = null;
655       if ( object1.result instanceof String  [] && object2.result instanceof String  [] ){
656          source1 = (String   [])object1.result;
657          target1 = (String   [])object2.result;
658       }
659       else if ( object1.result instanceof String  [] && object2.result instanceof String   ){
660          source1 = (String   [])object1.result;
661          target1 = new String  []{(String  )object2.result};
662       }
663       else if ( object1.result instanceof String   && object2.result instanceof String  [] ){
664          source1 = new String  []{(String  )object1.result};
665          target1 = (String   [])object2.result;
666       }
667       else {//if ( object1.result instanceof String && object2.result instanceof String ){
668          source1 = new String  []{(String  )object1.result};
669          target1 = new String  []{(String  )object2.result};
670       }
671       return source1 == null ? target1 == null ? 0 : -1
672                 : target1 == null ? 1 : compareResult(source1,target1);
673    }
674 
675    private int compareResult(String   []source,String   target[]){
676       for(int i = 0, j = 0; i < source.length && j < target.length; ++i,++j){
677          int cmp = source[i] == null ? target[j] == null ? 0 : -1
678       : target[j] == null ? 1 : checkString(source[i],target[i]);// source[i].compareTo(target[j]);
679          if ( cmp != 0 )
680             return cmp;
681       }
682       return source.length - target.length;
683    }
684 
685    private int checkString(String   source1,String   target1){
686       char []source = source1.replace('-','_').toCharArray();
687       char[] target = target1.replace('-','_').toCharArray();
688       int compare = 0;
689       for(int i = 0,j = 0; i < source.length && j < target.length && compare == 0; ++j,++i)
690          compare =  source[i] - target[j];
691       if (compare != 0 )
692          return compare;
693       return source.length - target.length;
694   }
695 }
696 
697 class RuleComparator implements Comparator  {
698 
699    RuleComparator(){
700    }
701 
702    public int compare(Object   source,Object   target){
703        return ((ProductionRules)source).ruleKey.compareToIgnoreCase(((ProductionRules)target).ruleKey);
704    }
705 }
706
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags