JAVA   7

InputParser.java

Guest on 13th May 2021 09:24:21 AM

  1.  
  2. import java.awt.event.*;
  3. import java.awt.*;
  4. import javax.swing.*;
  5.  
  6.  
  7. public class InputParser extends JFrame{
  8.  
  9.       private JLabel ComPrompt, MemPrompt, CpuPrompt;
  10.       private String result[] = null;
  11.       private JTextField ComInput, MemInput, CpuInput;
  12.       private JTextArea ComOutput, MemOutput, CpuOutput;
  13.       private JTextArea ComOutput2, MemOutput2, CpuOutput2;
  14.       private JTextArea ComSpecs, MemSpecs, CpuSpecs;
  15.       private String mem = "memory";
  16.       private String cpu = "cpu";
  17.       private String com = "computer";
  18.       private String [] mem_att = {"mkey", "brand", "speed", "price", "size"};
  19.       private String [] cpu_att = {"pkey", "brand","speed","price", "name"};
  20.       private String [] com_att = {"ckey", "cpu","memory","harddrive","motherboard"};
  21.       public  static String minterm [][] = null;
  22.       //logic values
  23.       String not = "not";
  24.      
  25.       public InputParser()
  26.       {
  27.             super("Testing SQL input");              
  28.            
  29.             Container c = getContentPane();
  30.             c.setLayout(new GridLayout(3,3));
  31.             Container comC = new Container();
  32.             comC.setLayout(new FlowLayout());
  33.            
  34.             // 1. Computer Part
  35.             ComPrompt = new JLabel("Computer Parts Query: (Primary)"); //input question
  36.             comC.add(ComPrompt);
  37.            
  38.             ComInput  = new JTextField(30); //enter SQL statments
  39.             ComInput.addActionListener(
  40.             new ActionListener()
  41.             {
  42.                   public void actionPerformed(ActionEvent e) //this is where tokenizing happening
  43.                   {
  44.                         int pred_sum[] = new int [5];
  45.                         String element = e.getActionCommand();
  46.                         result = element.split(", "); //result holds each string token
  47.                         // test input string
  48.                         boolean noError = false;
  49.                         boolean skip = false;
  50.                         for (int u = 0; u < result.length; u++)
  51.                         {
  52.                               noError = false;
  53.                               for (int v = 0; v < com_att.length; v++)
  54.                                     if (result[u].indexOf(com_att[v]) != -1)
  55.                                     {
  56.                                           noError = true;
  57.                                           pred_sum[v]++;
  58.                                     }
  59.                               if (!noError)
  60.                               {
  61.                                     skip = true;                       
  62.                                     ComOutput.setText("Attribute " + result[u] + " doesn't exist in the database!\n");
  63.                                     ComOutput2.setText("");
  64.                               }
  65.                         }
  66.                         if (!skip)
  67.                         {
  68.                               ComOutput.setText("Number of elements: " + result.length + "\nThe inputs are: \n");
  69.                        
  70.                               for(int i = 0; i < result.length; i++)
  71.                               {
  72.                                     ComOutput.append(result[i] + "\n");
  73.                               }
  74.                               ComOutput.append(generateMinTerm(result));
  75.                               String[] result = createMintermPredicates(minterm);
  76.                               ComOutput2.setText("The minterm predicates are: \n");
  77.                               // is there a problem?
  78.                               if (mintermProblem(pred_sum))
  79.                               {
  80.                                     System.out.println("We have a problem");
  81.                                     result = minimizeStringDuplicates(result, pred_sum, "motherboard");
  82.                               }
  83.                               for (int q = 0; q < result.length; q++)
  84.                                     if (result[q] != null)
  85.                                           ComOutput2.append(q+1 + ": " + result[q] + "\n");                            
  86.                               // do primary fragmentation only
  87.                               DriverTest driver = new DriverTest(0, 0, result, "computer.txt");                  
  88.                         }
  89.                   }
  90.             });
  91.            
  92.             comC.add(ComInput);
  93.  
  94.             ComSpecs = new JTextArea(5, 30);
  95.             //ComSpecs.setText("CPU Specifications:\n");
  96.             //ComSpecs.append("\n");
  97.             ComSpecs.setText("Attribute Name\tType\tValues\n");
  98.             ComSpecs.append("------------------------------------------------------\n");
  99.             ComSpecs.append("CKey\tInteger\t{1-80}\n");
  100.             ComSpecs.append("CPU\tInteger\t{1-40}\n");     
  101.             ComSpecs.append("Memory\tInteger\t{1-40}\n");
  102.             ComSpecs.append("HardDrive\tInteger\t{1-200}\n");
  103.             ComSpecs.append("Motherboard\tString\t{ASUS, GIGABYTE,}\n");
  104.             ComSpecs.append("\t\t{MSI, TYAN}\n\n");
  105.             ComSpecs.append("Note: Primary fragmentation only. \n");               
  106.             ComSpecs.setEditable(false);
  107.             comC.add(ComSpecs);          
  108.            
  109.             c.add (comC);
  110.                                    
  111.             ComOutput = new JTextArea(13, 30);
  112.             ComOutput.setEditable(false);
  113.             c.add(new JScrollPane(ComOutput));
  114.            
  115.             ComOutput2 = new JTextArea(13, 30);
  116.             ComOutput2.setEditable(false);
  117.             c.add(new JScrollPane(ComOutput2));
  118.            
  119.             // 2. CPU Part
  120.             Container cpuC = new Container();
  121.             cpuC.setLayout(new FlowLayout());
  122.            
  123.             CpuPrompt = new JLabel("CPU Parts Query: (Primary+Derived)"); //input question
  124.             cpuC.add(CpuPrompt);
  125.            
  126.             CpuInput  = new JTextField(30); //enter SQL statments
  127.             CpuInput.addActionListener(
  128.             new ActionListener()
  129.             {
  130.                   public void actionPerformed(ActionEvent e) //this is where tokenizing happening
  131.                   {
  132.                         int pred_sum[] = new int [5];                  
  133.                         String element = e.getActionCommand();
  134.                         result = element.split(", "); //result holds each string token
  135.                        
  136.                         // test input string
  137.                         boolean noError = false;
  138.                         boolean skip = false;
  139.                         for (int u = 0; u < result.length; u++)
  140.                         {
  141.                               noError = false;
  142.                               for (int v = 0; v < cpu_att.length; v++)                         
  143.                                     if (result[u].indexOf(cpu_att[v]) != -1)
  144.                                     {
  145.                                           noError = true;
  146.                                           pred_sum[v]++;
  147.                                     }                                        
  148.                               if (!noError)
  149.                               {
  150.                                     skip = true;                       
  151.                                     CpuOutput.setText("Attribute " + result[u] + " doesn't exist in the database!\n");
  152.                                     CpuOutput2.setText("");
  153.                               }
  154.                         }
  155.                        
  156.                         if (!skip)
  157.                         {                      
  158.                               CpuOutput.setText("Number of elements: " + result.length + "\nThe inputs are: \n");
  159.                               for(int i = 0; i < result.length; i++)
  160.                               {
  161.                                     CpuOutput.append(result[i] + "\n");
  162.                               }
  163.                               CpuOutput.append(generateMinTerm(result));
  164.                               String[] result = createMintermPredicates(minterm);
  165.                               CpuOutput2.setText("The minterm predicates are: \n");
  166.                               // is there a problem?
  167.                               if (mintermProblem(pred_sum))
  168.                               {
  169.                                     System.out.println("We have a problem");
  170.                                     if (pred_sum[1] > 1)
  171.                                           result = minimizeStringDuplicates(result, pred_sum, "brand");
  172.                                     if (pred_sum[4] > 1)
  173.                                           result = minimizeStringDuplicates(result, pred_sum, "name");                                                                 
  174.                               }                            
  175.                               for (int q = 0; q < result.length; q++)
  176.                                     if (result[q] != null)                         
  177.                                           CpuOutput2.append(q+1 + ": " + result[q] + "\n");                            
  178.                               // do primary and derived fragmentation                                
  179.                               DriverTest driver = new DriverTest(0, 0, result, "cpu.txt");                       
  180.                               DriverTest driver2 = new DriverTest(1, 1, result, "computer.txt");
  181.                         }
  182.                   }
  183.             });
  184.            
  185.             cpuC.add(CpuInput);
  186.            
  187.             CpuSpecs = new JTextArea(5, 30);
  188.             CpuSpecs.setText("Attribute Name\tType\tValues\n");
  189.             CpuSpecs.append("------------------------------------------------------\n");
  190.             CpuSpecs.append("PKey\tInteger\t{1-40}\n");
  191.             CpuSpecs.append("Brand\tString\t{INTEL, AMD, TRANSMETA}\n");           
  192.             CpuSpecs.append("Speed\tInteger\t{900-3400}\n");
  193.             CpuSpecs.append("Price\tInteger\t{31-424}\n");                   
  194.             CpuSpecs.append("Name\tString\t{Pentium4, AthlonXP,}\n");
  195.             CpuSpecs.append("\t\t{XEON, CRUSOE,}\n");      
  196.             CpuSpecs.append("\t\t{CELERON, DURON}\n\n");         
  197.             CpuSpecs.append("Note: Derived fragmentation on the computer \n");
  198.             CpuSpecs.append("           relation is performed automatically. \n");       
  199.             CpuSpecs.setEditable(false);
  200.             cpuC.add(CpuSpecs);          
  201.                                    
  202.             c.add(cpuC);
  203.                                    
  204.             CpuOutput = new JTextArea(13, 30);
  205.             CpuOutput.setEditable(false);
  206.             c.add(new JScrollPane(CpuOutput));
  207.  
  208.             CpuOutput2 = new JTextArea(13, 30);
  209.             CpuOutput2.setEditable(false);
  210.             c.add(new JScrollPane(CpuOutput2));
  211.            
  212.             // 3. Memory Part
  213.             Container memC = new Container();
  214.             memC.setLayout(new FlowLayout());        
  215.            
  216.             MemPrompt = new JLabel("Memory Parts Query: (Primary+Derived)"); //input question        
  217.             memC.add(MemPrompt);
  218.            
  219.             MemInput  = new JTextField(30); //enter SQL statments
  220.             MemInput.addActionListener(
  221.             new ActionListener()
  222.             {
  223.                   public void actionPerformed(ActionEvent e) //this is where tokenizing happening
  224.                   {
  225.                         int pred_sum[] = new int [5];                  
  226.                         String element = e.getActionCommand();
  227.                         result = element.split(", "); //result holds each string token
  228.                  
  229.                         // test input string
  230.                         boolean noError = false;
  231.                         boolean skip = false;
  232.                         for (int u = 0; u < result.length; u++)
  233.                         {
  234.                               noError = false;
  235.                               for (int v = 0; v < mem_att.length; v++)
  236.                                     if (result[u].indexOf(mem_att[v]) != -1)
  237.                                     {
  238.                                           noError = true;
  239.                                           pred_sum[v]++;
  240.                                     }                                        
  241.                               if (!noError)
  242.                               {
  243.                                     skip = true;                       
  244.                                     MemOutput.setText("Attribute " + result[u] + " doesn't exist in the database!\n");
  245.                                     MemOutput2.setText("");
  246.                               }
  247.                         }
  248.                        
  249.                         if (!skip)
  250.                         {                                  
  251.                        
  252.                               MemOutput.setText("Number of elements: " + result.length + "\nThe inputs are: \n");
  253.                               for(int i = 0; i < result.length; i++)
  254.                                     MemOutput.append(result[i] + "\n");
  255.                               MemOutput.append(generateMinTerm(result));
  256.                               String[] result = createMintermPredicates(minterm);
  257.                               MemOutput2.setText("The minterm predicates are: \n");
  258.                               // is there a problem?
  259.                               if (mintermProblem(pred_sum))
  260.                               {
  261.                                     System.out.println("We have a problem");                               
  262.                                     if (pred_sum[1] > 1)
  263.                                           result = minimizeStringDuplicates(result, pred_sum, "brand");
  264.                                           result = minimizeIntDuplicates(result, pred_sum, "size");
  265.                               }
  266.                               for (int q = 0; q < result.length; q++)
  267.                                     if (result[q] != null)                         
  268.                                           MemOutput2.append(q+1 + ": " + result[q] + "\n");                            
  269.                               // do primary and derived fragmentation                                                  
  270.                               DriverTest driver = new DriverTest(0, 0, result, "memory.txt");
  271.                               DriverTest driver2 = new DriverTest(1, 0, result, "computer.txt");                                                     
  272.                         }
  273.                   }
  274.             });
  275.                        
  276.             memC.add(MemInput);
  277.            
  278.             MemSpecs = new JTextArea(5, 30);
  279.             MemSpecs.setText("Attribute Name\tType\tValues\n");
  280.             MemSpecs.append("------------------------------------------------------\n");
  281.             MemSpecs.append("MKey\tInteger\t{1-40}\n");
  282.             MemSpecs.append("Brand\tString\t{KINGSTON, MICRON,}\n");
  283.             MemSpecs.append("\t\t{RAMBUS}\n");                   
  284.             MemSpecs.append("Speed\tInteger\t{100,133,2400,}\n");
  285.             MemSpecs.append("\t\t{2700,3200,3700}\n");           
  286.             MemSpecs.append("Price\tInteger\t{9-175}\n");
  287.             MemSpecs.append("Size\tInteger\t{64,128,256,512,1024}\n\n");     
  288.             MemSpecs.append("Note: Derived fragmentation on the computer \n");
  289.             MemSpecs.append("           relation is performed automatically. \n");             
  290.             MemSpecs.setEditable(false); 
  291.             memC.add(MemSpecs);
  292.  
  293.             c.add(memC);
  294.                                    
  295.             MemOutput = new JTextArea(13, 30);
  296.             MemOutput.setEditable(false);
  297.             c.add(new JScrollPane(MemOutput));                   
  298.            
  299.             MemOutput2 = new JTextArea(13, 30);
  300.             MemOutput2.setEditable(false);
  301.             c.add(new JScrollPane(MemOutput2));      
  302.  
  303.             setSize(1024,768);
  304.             setVisible(true);
  305.       }
  306.      
  307.       public String generateMinTerm(String [] element)
  308.       {
  309.             String not = null;
  310.             int i = 0;
  311.             double power = Math.pow(2,element.length); //ie. 3 elements = 8 minterms
  312.             int loopCnt = (int)power; //convert to int..
  313.             boolean no = false; //checking for NOT
  314.             //System.out.println("loopCnt: " + loopCnt); //debug
  315.             int q = loopCnt/2;
  316.             minterm = new String [element.length][loopCnt]; // matrix [predicate x loopCnt]
  317.            
  318.             for(i = 0; i < element.length; i++)
  319.             {
  320.                   String n = element[i].toLowerCase();;
  321.                   if (n.indexOf("not") != -1)
  322.                   not = n.substring(n.indexOf('n'), n.indexOf("t")+1);
  323.                  
  324.                   if(not != null) //check for NOT
  325.                         no = true;
  326.                  
  327.                   if(no) //not is true
  328.                   {
  329.                         int j = 0;
  330.                         int y = q;
  331.                         int x = 0;
  332.                         for (int k = 0; k < loopCnt/(q*2); k++)
  333.                         {
  334.                               for(j = x; j < y; j++)
  335.                                     minterm[i][j] = n;
  336.                               y += q;
  337.                               for(x = j; x < y; x++)
  338.                                     minterm[i][x] = n.substring(4,n.length()); // take out not                   
  339.                               y += q;
  340.                         }
  341.                         q /= 2;
  342.                   }
  343.                   else // not is false
  344.                   {
  345.                         int j = 0;
  346.                         int y = q;
  347.                         int x = 0;
  348.                         for (int k = 0; k < loopCnt/(q*2); k++)
  349.                         {
  350.                               for(j = x; j < (y); j++)
  351.                                     minterm[i][j] = n;
  352.                               y += q;
  353.                               for(x = j; x < y; x++)
  354.                                     minterm[i][x] = ("not ").concat(n); //put in 'not'
  355.                               y += q;
  356.                         }
  357.                         q /= 2;    
  358.                   }
  359.                  
  360.             }
  361.             return null;
  362.       }
  363.      
  364.       public static String[] createMintermPredicates(String [][] minterm)
  365.       {
  366.             String result[] = new String[minterm[0].length];
  367.             for (int p = 0; p < minterm[0].length; p++)
  368.                   result[p] = minterm[0][p];
  369.             for (int r = 0; r < minterm[0].length; r++)
  370.             {
  371.                   for (int s = 1; s < minterm.length; s++)
  372.                   {
  373.                         result[r] = result[r].concat(" and " + minterm[s][r]);
  374.                   }
  375.             }
  376.             // test output
  377.             //for (int q = 0; q < result.length; q++)
  378.                   //System.out.println("result[" + q + "] = " + result[q]);
  379.             return result;
  380.       }
  381.      
  382.       // the goal of this method is to get rid of the duplicate or contradictory ints
  383.       public static String[] minimizeIntDuplicates(String[] mintermPreds, int[] pred_sum, String attribute)
  384.       {
  385.             String op1 = null;
  386.             String op2 = null;
  387.             int num1 = null;
  388.             int num2 = null;
  389.             int m[] = new int[2];
  390.             for (int j = 0; j < mintermPreds.length; j++)
  391.             {
  392.                   m = getAttrib(mintermPreds[j], attribute);
  393.                   System.out.println(m[0] + " " + m[1] + " " + attribute.length());
  394.                   op1 = mintermPreds[j].substring(m[0]+attribute.length()+1, m[0]+attribute.length()+3);
  395.                   op2 = mintermPreds[j].substring(m[1]+attribute.length()+1, m[1]+attribute.length()+3);
  396.                   op1.trim();
  397.                   op2.trim();
  398.                   System.out.println(op1 + " " + op2);
  399.                   num1 = mintermPreds[j].substring(m[0]+attribute.length()+1+op1.length(), m[0]+attribute.length()+3);
  400.                   num2 = mintermPreds[j].substring(m[1]+attribute.length()+1+op1, m[1]+attribute.length()+3);          
  401.                   System.out.println(num1 + " " + num2);         
  402.            
  403.             } // of for      
  404.             return mintermPreds;
  405.       }
  406.      
  407.       // the goal of this method is to get rid of the duplicate or contradictory Strings
  408.       public static String[] minimizeStringDuplicates(String[] mintermPreds, int[] pred_sum, String attribute)
  409.       {
  410.             int m[] = new int[2];  
  411.             for (int j = 0; j < mintermPreds.length; j++)
  412.             {
  413.                   if (mintermPreds[j] != null)
  414.                   {
  415.                         m = getNots(mintermPreds[j], attribute); // get location of "NOT attributes"s
  416.                         if ((m[0] == -1) && (m[1]== -1)) // we have two "non NOTs", so it's worthless
  417.                               mintermPreds[j] = null;
  418.                         else if (!(m[0] == -1) && (m[1]== -1)) // we have one "non NOT", one "NOT"               
  419.                               //delete NOT part
  420.                               if (m[0] == 0) // "not" is at very beginning
  421.                                     mintermPreds[j] = mintermPreds[j].substring(mintermPreds[j].indexOf(" and")+5, mintermPreds[j].length());                    
  422.                               else
  423.                               { // "not" is somewhere in the middle
  424.                                     String temp = null;
  425.                                     temp = mintermPreds[j].substring(0,m[0]-4); // first part
  426.                                     int jj = mintermPreds[j].indexOf("'", m[0]);   
  427.                                     int kk = mintermPreds[j].indexOf("'", jj+1);
  428.                                     if ((kk+1) != mintermPreds[j].length()) // if not at end already
  429.                                           temp = temp.concat(mintermPreds[j].substring(kk+2,mintermPreds[j].length()));
  430.                                     mintermPreds[j] = temp;
  431.                               }
  432.                   } // of if
  433.             }
  434.             mintermPreds = removeNulls(mintermPreds);      
  435.             return mintermPreds;
  436.       }
  437.      
  438.       // used for minimizeStringDuplicates
  439.       public static int[] getNots(String input, String name)
  440.       {
  441.             int[] nots = new int[2];           
  442.             nots[0] = input.indexOf("not " + name);
  443.             nots[1] = input.indexOf("not " + name, nots[0]+1);
  444.             return nots;
  445.       }
  446.      
  447.       // used for minimizeIntDuplicates
  448.       public static int[] getAttrib(String input, String name)
  449.       {
  450.             int[] attribs = new int[2];        
  451.             attribs[0] = input.indexOf(name);
  452.             attribs[1] = input.indexOf(name, attribs[0]+1);
  453.             return attribs;
  454.       }
  455.      
  456.      
  457.       // removes the null entries from a String array
  458.       // (actually just moves them to the end, but works for our purposes)
  459.       public static String[] removeNulls(String[] input)
  460.       {
  461.             String result[] = new String[input.length];
  462.             int j = 0;
  463.             for (int i = 0; i < input.length; i++)
  464.             {
  465.                   if (input[i] != null)
  466.                         result[j++] = input[i];
  467.             }
  468.             System.out.println(result);
  469.             return result;
  470.       }
  471.      
  472.       // returns true if more than one occurance of an attribute in the minterms
  473.       public static boolean mintermProblem(int[] pred_sum)
  474.       {
  475.             boolean answer = false;
  476.             for (int j=0; j < pred_sum.length; j++)
  477.                   if (pred_sum[j] > 1)
  478.                         answer = true;
  479.             return answer;
  480.       }
  481.      
  482.       public static void main(String[] args)
  483.       {
  484.             InputParser ip = new InputParser();
  485.             ip.addWindowListener(
  486.             new WindowAdapter()
  487.             {
  488.                   public void windowClosing(WindowEvent e)
  489.                   {
  490.                         System.exit(0);
  491.                   }
  492.             });
  493.  
  494.       }
  495. }

Raw Paste


Login or Register to edit or fork this paste. It's free.