/** @return The next command from the user. */
  public Command getCommands() {
    String inputLine; // will hold the full input line
    String word1 = null;
    String word2 = null;

    System.out.print("> "); // print prompt

    inputLine = reader.nextLine();

    // Find up to two words on the line.
    Scanner tokenizer = new Scanner(inputLine);
    if (tokenizer.hasNext()) {
      word1 = tokenizer.next(); // get first word
      if (tokenizer.hasNext()) {
        word2 = tokenizer.next(); // get second word
        // note: we just ignore the rest of the input line.
      }
    }

    // Now check whether this word is known. If so, create a command
    // with it. If not, create a "null" command (for unknown command).
    if (commands.isCommand(word1)) {
      return new Command(word1, word2);
    } else {
      return new Command(null, word2);
    }
  }
Example #2
0
  public String loadStationData() {
    int x = 0;
    try {
      File f = new File("data\\FBIN.txt");
      Scanner scan = new Scanner(f);
      while (breakLoop == false) {

        temp = scan.nextLine();
        if (scan.hasNext() && x > 6) {
          x++;

          stations.add(temp);

        } else if (scan.hasNext() && x < 7) {
          x++;
        } else {
          breakLoop = true;
        }
      }
      scan.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
    breakLoop = false;

    return temp;
  }
 public static void main(String[] args) {
   Scanner sc = new Scanner(System.in);
   Scanner scL;
   String s, a;
   char c;
   boolean t;
   while (true) {
     s = sc.nextLine();
     if (s.equals("*")) {
       break;
     }
     scL = new Scanner(s);
     a = "";
     c = '\0';
     t = true;
     if (scL.hasNext()) {
       a = scL.next().toLowerCase();
       c = a.charAt(0);
     }
     while (scL.hasNext() && t) {
       a = scL.next().toLowerCase();
       if (a.charAt(0) != c) {
         t = false;
       }
     }
     if (t) {
       System.out.println("Y");
     } else {
       System.out.println("N");
     }
   }
 }
Example #4
0
 public static void main(String args[]) throws IOException {
   Scanner sf = new Scanner(new File("D:\\IB CS\\temp_Aman\\StudentsScores.in.txt"));
   int maxIndx = -1;
   String text[] = new String[1000];
   while (sf.hasNext()) // this allows the program to assign each line in the text file a variable
   {
     maxIndx++;
     text[maxIndx] = sf.nextLine();
   }
   for (int j = 0; j <= 4; j++) {
     Scanner sc = new Scanner(text[j]);
     String name =
         sc.next(); // this helps identify the Strings, which are the names of students, in each
     // line
     double sum =
         0.0; // it starts the sum and count variables with zero because they change as they move
     // along with the while loop
     int count = 0;
     while (sc.hasNext()) {
       sum = sum + sc.nextDouble(); // this while loop helps find out the number of integers in the
       // line and adds all of these numbers as well
       count = count + 1;
     }
     double avg = sum / count;
     int y = (int) Math.round(avg); // this converts the double variable avg to an integer
     System.out.println(name + "," + " average = " + y);
   }
 }
Example #5
0
  private void leLabirinto(Scanner arquivo) throws Exception {
    String cmd = arquivo.next().toLowerCase();
    while (cmd.equals("room")) {
      int salaId = arquivo.nextInt();
      salas[salaId] = new Sala();
      Sala sala = salas[salaId];

      String direcao = arquivo.next();

      do {
        if (arquivo.hasNextInt()) {
          salaId = arquivo.nextInt();
        } else if (arquivo.next().equalsIgnoreCase("EXIT")) {
          salaId = 0;
        } else break;

        sala.addConexao(direcao, salaId);

        if (!arquivo.hasNext()) return;
        cmd = arquivo.next().toLowerCase();
        if (cmd.equals("trap")) {
          sala.setArmadilha(direcao);
          if (!arquivo.hasNext()) return;
          cmd = arquivo.next();
        }
        direcao = cmd;
      } while (!cmd.equals("room"));
    }
    throw new Exception("Arquivo de descricao do labirinto invalido.");
  }
Example #6
0
  static void loadJumps() throws IOException {
    InputStream in = getInput(JUMPS_FNAME);
    Scanner sc = makeScanner(in);

    while (sc.hasNext())
      try {
        int a = sc.nextInt();
        int b = sc.nextInt();

        StarSystem sa = systems.get(a);
        StarSystem sb = systems.get(b);
        Jump j = new Jump(sa, sb);
        sa.jumps.add(j);
        sb.jumps.add(j);
        jumps.add(j);
      } catch (Exception e) {
        System.err.println("Parsing error loading jumps.");
        if (sc.hasNext()) System.err.println("Problematic token: " + sc.next());
        else System.err.println("No tokens remaining.");
        System.err.println("e");

        sc.close();
        in.close();

        throw new RuntimeException(e);
      }

    sc.close();
    in.close();
  }
  /**
   * This API compares if two files content is identical. It ignores extra spaces and new lines
   * while comparing
   *
   * @param sourceFile
   * @param destFile
   * @return
   * @throws Exception
   */
  public static boolean isFilesIdentical(File sourceFile, File destFile) throws Exception {
    try {
      Scanner sourceFileScanner = new Scanner(sourceFile);
      Scanner destFileScanner = new Scanner(destFile);

      while (sourceFileScanner.hasNext()) {
        /*
         * If source file is having next token
         * then destination file also should have next token,
         *	else they are not identical.
         */
        if (!destFileScanner.hasNext()) {
          return false;
        }
        if (!sourceFileScanner.next().equals(destFileScanner.next())) {
          return false;
        }
      }
      /*
       * Handling the case where source file is empty
       * and destination file is having text
       */
      if (destFileScanner.hasNext()) {
        return false;
      } else {
        return true;
      }
    } catch (Exception e) {
      e.printStackTrace();
      throw e;
    }
  }
 /** Does not close <var>r</var>. */
 public static SrgFile read(Reader r, boolean reverse) throws IOException {
   @SuppressWarnings("resource")
   Scanner in = new Scanner(r);
   SrgFile rv = new SrgFile();
   while (in.hasNextLine()) {
     if (in.hasNext("CL:")) {
       in.next();
       String obf = in.next();
       String deobf = in.next();
       if (reverse) rv.classes.put(deobf, obf);
       else rv.classes.put(obf, deobf);
     } else if (in.hasNext("FD:")) {
       in.next();
       String obf = in.next();
       String deobf = in.next();
       if (reverse) rv.fields.put(deobf, getLastComponent(obf));
       else rv.fields.put(obf, getLastComponent(deobf));
     } else if (in.hasNext("MD:")) {
       in.next();
       String obf = in.next();
       String obfdesc = in.next();
       String deobf = in.next();
       String deobfdesc = in.next();
       if (reverse) rv.methods.put(deobf + deobfdesc, getLastComponent(obf));
       else rv.methods.put(obf + obfdesc, getLastComponent(deobf));
     } else {
       in.nextLine();
     }
   }
   return rv;
 }
 public void loadEnvironment(File modelFile) {
   reset();
   try {
     Scanner input = new Scanner(modelFile);
     while (input.hasNext()) {
       Scanner line = new Scanner(input.nextLine());
       if (line.hasNext()) {
         String type = line.next();
         if (GRAVITY_KEYWORD.equals(type)) {
           gravityCommand(line);
         } else if (VISCOSITY_KEYWORD.equals(type)) {
           viscosityCommand(line);
         } else if (CENTEROFMASS_KEYWORD.equals(type)) {
           centerOfMassCommand(line);
         } else if (WALLREPULSION_KEYWORD.equals(type)) {
           wallRepulsionCommand(line);
         }
       }
     }
     input.close();
   } catch (FileNotFoundException e) {
     // should not happen because File came from user selection
     e.printStackTrace();
   }
 }
Example #10
0
 public boolean ok(String out, String reference) {
   // log.fine("out1: " + a);
   // log.fine("out2: " + b);
   Scanner sa = new Scanner(out);
   Scanner sb = new Scanner(reference);
   while (sa.hasNext() && sb.hasNext()) {
     if (sa.hasNextDouble() || sb.hasNextDouble()) {
       if (!sa.hasNextDouble() || !sb.hasNextDouble()) return true;
       double da = sa.nextDouble();
       double db = sb.nextDouble();
       double d_abs = Math.abs(da - db);
       double d_rel = d_abs / Math.abs(db);
       if (!(d_abs < EPS || d_rel < EPS)) {
         log.fine("NOK, " + da + " too far from " + db);
         return false;
       }
     } else {
       String xa = sa.next();
       String xb = sb.next();
       if (!xa.equals(xb)) {
         log.fine("NOK, " + xa + " != " + xb);
         return false;
       }
     }
   }
   if (sa.hasNext() || sb.hasNext()) {
     log.fine("NOK: different number of tokens.");
     return false;
   }
   return true;
 }
Example #11
0
 public String[] getEmail() {
   LinkedSet<String> ls = new LinkedSet<String>();
   int counter = 0;
   String bod = this.getBody();
   String from = this.getFrom();
   Scanner f = new Scanner(from);
   Scanner b = new Scanner(bod);
   String pattern =
       "^[A-Za-z0-9]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
   while (b.hasNext()) {
     String newString = b.next();
     String finalString = newString.replaceAll(pattern, "");
     if (newString.matches(pattern)) {
       ls.add(newString);
       counter++;
     }
   }
   while (f.hasNext()) {
     String newString = f.next();
     String finalString = newString.replaceAll(pattern, "");
     if (newString.matches(pattern)) {
       ls.add(newString);
       counter++;
     }
   }
   String[] Lastemails = new String[ls.size()];
   if (ls.size() > 0) {
     for (int i = 0; i < ls.size(); i++) {
       Lastemails[i] = ls.get(i + 1);
     }
   }
   return Lastemails;
 }
Example #12
0
 public static void tokenize(String regexStr, String source, String delimiters) { // (1)
   System.out.print("Index:   ");
   for (int i = 0; i < source.length(); i++) {
     System.out.print(i % 10);
   }
   System.out.println();
   System.out.println("Target:  " + source);
   System.out.println("Delimit: " + delimiters);
   System.out.println("Pattern: " + regexStr);
   System.out.print("Match:   ");
   Pattern pattern = Pattern.compile(regexStr); // (2)
   Scanner lexer = new Scanner(source); // (3)
   if (!delimiters.equalsIgnoreCase("default")) lexer.useDelimiter(delimiters); // (5)
   while (lexer.hasNext()) { // (4)
     if (lexer.hasNext(pattern)) { // (5)
       String matchedStr = lexer.next(pattern); // (5)
       MatchResult matchResult = lexer.match(); // (6)
       int startCharIndex = matchResult.start();
       int lastPlus1Index = matchResult.end();
       int lastCharIndex = startCharIndex == lastPlus1Index ? lastPlus1Index : lastPlus1Index - 1;
       out.print("(" + startCharIndex + "," + lastCharIndex + ":" + matchedStr + ")");
     } else {
       lexer.next(); // (7)
     }
   }
   System.out.println();
 }
  public void initialize() {
    try {
      InputStream stream = schema.getInputStream();
      Scanner scanner = new Scanner(stream);
      StringBuilder sql = new StringBuilder();
      while (scanner.hasNext()) {
        sql.append(scanner.nextLine());
        sql.append("\n");
      }
      scanner.close();
      stream.close();
      Connection connection = null;
      Statement statement = null;
      try {
        connection = dataSource.getConnection();
        statement = connection.createStatement();
        statement.execute(sql.toString());
      } catch (SQLException ex) {
        ex.printStackTrace();
        throw new RuntimeException(ex);
      } finally {
        if (null != connection) {
          try {
            connection.close();
          } catch (SQLException ex) {
          }
        }
      }

      stream = data.getInputStream();
      scanner = new Scanner(stream);
      sql = new StringBuilder();
      while (scanner.hasNext()) {
        sql.append(scanner.nextLine());
        sql.append("\n");
      }
      scanner.close();
      stream.close();
      connection = null;
      statement = null;
      try {
        connection = dataSource.getConnection();
        statement = connection.createStatement();
        statement.executeUpdate(sql.toString());
      } catch (SQLException ex) {
        ex.printStackTrace();
        throw new RuntimeException(ex);
      } finally {
        if (null != connection) {
          try {
            connection.close();
          } catch (SQLException ex) {
          }
        }
      }

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  public static void testMatchSampleFiles(String Path1, String Path2) {

    try {
      Scanner sc1 = new Scanner(new File(Path1));
      Scanner sc2 = new Scanner(new File(Path2));

      Assert.assertTrue(sc1.hasNext());
      Assert.assertTrue(sc2.hasNext());

      String header1 = sc1.next();
      String header2 = sc2.next();

      Assert.assertTrue(header1.equals(header2));

      while (sc1.hasNext() && sc2.hasNext()) {
        String line1 = sc1.next();
        String line2 = sc2.next();

        Assert.assertTrue(line1.equals(line2));
      }

      sc1.close();
      sc2.close();

    } catch (FileNotFoundException e) {
      Assert.assertTrue(false);
      e.printStackTrace();
    }
  }
Example #15
0
 public final void loadAllPresets() {
   try {
     final File _f =
         new File("plugins/VoxelSniper/presetsBySniper/" + this.player.getName() + ".txt");
     if (_f.exists()) {
       final Scanner _snr = new Scanner(_f);
       final int[] _presetsHolder = new int[Sniper.SAVE_ARRAY_SIZE];
       while (_snr.hasNext()) {
         try {
           this.readingString = _snr.nextLine();
           final int _key = Integer.parseInt(this.readingString);
           this.readingBrush = this.myBrushes.get(_snr.nextLine());
           this.brushPresets.put(_key, this.readingBrush);
           _presetsHolder[Sniper.SAVE_ARRAY_VOXEL_ID] = Integer.parseInt(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_REPLACE_VOXEL_ID] = Integer.parseInt(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_DATA_VALUE] = Byte.parseByte(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_BRUSH_SIZE] = Integer.parseInt(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_VOXEL_HEIGHT] = Integer.parseInt(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_CENTROID] = Integer.parseInt(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_REPLACE_DATA_VALUE] = Byte.parseByte(_snr.nextLine());
           _presetsHolder[Sniper.SAVE_ARRAY_RANGE] = Integer.parseInt(_snr.nextLine());
           this.brushPresetsParams.put(_key, _presetsHolder);
         } catch (final NumberFormatException _e) {
           boolean _first = true;
           while (_snr.hasNext()) {
             String _keyS;
             if (_first) {
               _keyS = this.readingString;
               _first = false;
             } else {
               _keyS = _snr.nextLine();
             }
             this.readingBrush = this.myBrushes.get(_snr.nextLine());
             this.brushPresetsS.put(_keyS, this.readingBrush);
             _presetsHolder[Sniper.SAVE_ARRAY_VOXEL_ID] = Integer.parseInt(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_REPLACE_VOXEL_ID] =
                 Integer.parseInt(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_DATA_VALUE] = Byte.parseByte(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_BRUSH_SIZE] = Integer.parseInt(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_VOXEL_HEIGHT] = Integer.parseInt(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_CENTROID] = Integer.parseInt(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_REPLACE_DATA_VALUE] =
                 Byte.parseByte(_snr.nextLine());
             _presetsHolder[Sniper.SAVE_ARRAY_RANGE] = Integer.parseInt(_snr.nextLine());
             this.brushPresetsParamsS.put(_keyS, _presetsHolder);
           }
         }
       }
       _snr.close();
     }
   } catch (final Exception _e) {
     _e.printStackTrace();
   }
 }
Example #16
0
  // experimental
  // ====================================================================
  // ====================================================================
  // ====================================================================
  private void readAndDrawBIGGraph(String file) {
    // behövs inte än
    // @TODO
    // hur rita flera linjer mellan 2 noder? (för flera linjer)
    // reading of the graph should be done in the graph itself
    // it should be possible to get an iterator over nodes and one over edges
    // read in all the stops and lines and draw the lmap
    Scanner indata = null;
    // insert into p-queue to get them sorted
    names = new PriorityQueue<String>();
    try {
      // Read stops and put them in the node-table
      // in order to give the user a list of possible stops
      // assume input file is correct
      indata = new Scanner(new File(file + "-stops.txt"), "ISO-8859"); //
      while (indata.hasNext()) {
        String hpl = indata.next().trim();
        int xco = indata.nextInt();
        int yco = indata.nextInt();
        noderna.add(new BusStop(hpl, xco, yco));
        names.add(hpl);
        // Draw
        // this is a fix: fixa att Kålltorp och Torp är samma hållplats
        if (hpl.equals("Torp")) {
          xco += 11;
          hpl = "   / Torp";
        }
        karta.drawString(hpl, xco, yco, DrawGraph.Layer.BASE);
      }
      indata.close();

      //  Read in the lines and add to the graph
      indata = new Scanner(new File(file + "-lines.txt"), "ISO-8859");
      grafen = new DirectedGraph<BusEdge>(noderna.noOfNodes());
      Color color =
          new Color((float) Math.random(), (float) Math.random(), (float) Math.random()); //
      String lineNo = "1"; //
      while (indata.hasNext()) { // assume lines are correct
        int from = noderna.find(indata.next()).getNodeNo();
        int to = noderna.find(indata.next()).getNodeNo();
        grafen.addEdge(new BusEdge(from, to, indata.nextInt(), lineNo));
        indata.nextLine(); // skip rest of line
        // Draw
        BusStop busFrom = noderna.find(from);
        BusStop busTo = noderna.find(to);
        karta.drawLine(
            busFrom.xpos, busFrom.ypos, busTo.xpos, busTo.ypos, color, 2.0f, DrawGraph.Layer.BASE);
      }
      indata.close();
    } catch (FileNotFoundException fnfe) {
      throw new RuntimeException(" Indata till busshållplatserna saknas");
    }
    karta.repaint();
  } // end readAndDrawBIGGraph
 public static int initializeCentroids() throws FileNotFoundException {
   int i, k, index, numClust = 0;
   Review rv;
   String reviews = new String();
   String singleRv = new String();
   String reviewer = new String();
   String rating = new String();
   for (i = 0; i < maxClusters; i++) {
     centroids[i] = new Cluster();
     centroids_ref[i] = new Cluster();
   }
   File modelFile = new File(strModelFile);
   Scanner opnScanner = new Scanner(modelFile);
   while (opnScanner.hasNext()) {
     k = opnScanner.nextInt();
     centroids_ref[k].similarity = opnScanner.nextFloat();
     centroids_ref[k].movie_id = opnScanner.nextLong();
     centroids_ref[k].total = opnScanner.nextShort(); // Leo
     centroids_ref[k].total = attrNum + 1;
     reviews = opnScanner.next();
     Scanner revScanner = new Scanner(reviews).useDelimiter(",");
     // while(revScanner.hasNext()){ //Leo
     int attrCnt = 0;
     while (revScanner.hasNext() && attrCnt < attrNum) {
       singleRv = revScanner.next();
       index = singleRv.indexOf("_");
       // reviewer = new String(singleRv.substring(0,index)); //Leo
       reviewer = new String(String.valueOf(attrCnt));
       rating = new String(singleRv.substring(index + 1));
       rv = new Review();
       rv.rater_id = Integer.parseInt(reviewer);
       rv.rating = (byte) Integer.parseInt(rating);
       centroids_ref[k].reviews.add(rv);
       attrCnt++;
     }
   }
   // implementing naive bubble sort as maxClusters is small
   // sorting is done to assign top most cluster ids in each iteration
   for (int pass = 1; pass < maxClusters; pass++) {
     for (int u = 0; u < maxClusters - pass; u++) {
       if (centroids_ref[u].movie_id < centroids_ref[u + 1].movie_id) {
         Cluster temp = new Cluster(centroids_ref[u]);
         centroids_ref[u] = centroids_ref[u + 1];
         centroids_ref[u + 1] = temp;
       }
     }
   }
   for (int l = 0; l < maxClusters; l++) {
     if (centroids_ref[l].movie_id != -1) {
       numClust++;
     }
   }
   return numClust;
 }
Example #18
0
 private static String compileContent(InputStream stream) {
   String compiledContent = "";
   Scanner s = new Scanner(stream);
   while (s.hasNext()) {
     compiledContent += s.next();
     if (s.hasNext()) {
       compiledContent += " ";
     }
   }
   return compiledContent;
 }
  /**
   * Originally designed for Iris plants, could be used for any thing that follows this file format
   *
   * <p>double, double, double, double, string
   *
   * <p>Phase takes a scanner and create a list of QuickSubject.
   *
   * @param scanner
   * @return
   */
  public static List<QuickSubject> phase(Scanner scanner) {
    List<QuickSubject> li = new ArrayList<>();
    scanner.useDelimiter(" ");

    mainLoop:
    while (scanner.hasNext()) {

      while (!scanner.hasNextDouble() && !scanner.hasNextFloat()) {
        scanner.next();
        if (!scanner.hasNext()) {
          break mainLoop; // ends loop
        }
      }

      double sepalLength = scanner.nextDouble();

      while (!scanner.hasNextDouble() && !scanner.hasNextFloat()) {
        scanner.next();
        if (!scanner.hasNext()) {
          break mainLoop;
        }
      }
      double sepalWidth = scanner.nextDouble();
      while (!scanner.hasNextDouble() && !scanner.hasNextFloat()) {
        scanner.next();
        if (!scanner.hasNext()) {
          break mainLoop;
        }
      }
      double petalLength = scanner.nextDouble();
      while (!scanner.hasNextDouble() && !scanner.hasNextFloat()) {
        scanner.next();
        if (!scanner.hasNext()) {
          break mainLoop;
        }
      }

      double petalWidth = scanner.nextDouble();

      if (!scanner.hasNextLine()) {
        break;
      }
      String label = scanner.nextLine().substring(1);

      // System.out.println(sepalLength+" "+sepalWidth+" "+petalLength+" "+petalWidth+" "+label);

      li.add(new QuickSubject(sepalLength, sepalWidth, petalLength, petalWidth, label));
    }

    scanner.close();

    return li;
  }
Example #20
0
  public static void main(String[] args) throws Exception {

    // accept argument to set threshold support and confidence
    int support = 3;
    double confidence = 0.65;
    int argsLength = args.length;
    if (argsLength >= 1) {
      if (argsLength >= 2) {
        support = Integer.parseInt(args[1]);
        if (argsLength >= 3) {
          confidence = Double.parseDouble(args[2]);
          confidence = confidence / 100;
          if (argsLength >= 4) {
            expandLevel = Integer.parseInt(args[3]);
          }
        }
      }
    }

    Scanner scanner = new Scanner(System.in);
    Pattern caller_p = Pattern.compile("Call.*'(.*)'.*");
    Pattern callee_p = Pattern.compile(".*'(.*)'.*");
    Matcher caller_m = null;
    Matcher callee_m = null;
    String line = null;
    while (scanner.hasNext()) {
      line = scanner.nextLine();
      caller_m = caller_p.matcher(line);
      if (caller_m.matches() /*&& !"main".equals(caller_m.group(1))*/) {
        nearByCallees.clear();
        Set<String> callees = new HashSet<String>();
        while (scanner.hasNext()) {
          line = scanner.nextLine();
          if (line.length() == 0) {
            break;
          }
          callee_m = callee_p.matcher(line);
          if (callee_m.matches()) {
            addValueToMap(callee_m.group(1), caller_m.group(1));
            nearByCallees.add(callee_m.group(1));
            callees.add(callee_m.group(1));
          }
        }
        if (!callees.isEmpty()) {
          callerCallee.put(caller_m.group(1), callees);
        }
      }
    }
    scanner.close();

    // Traverse HashMap 'location' and print bug
    printBug(support, confidence);
  }
  private static String getInputFromUser(String question, String errorMessage, String pattern) {
    showUser(question);
    Scanner scanIn = new Scanner(System.in);

    while (scanIn.hasNext() && !scanIn.hasNext(pattern)) {
      scanIn.next();
      showUser(errorMessage);
    }

    String returnValue = scanIn.next(pattern);

    return returnValue;
  }
Example #22
0
  @Override
  public CatBuildCommand command(String command) throws Exception {
    // magrit cat-build SHA1
    Scanner s = new Scanner(command);
    s.useDelimiter("\\s{1,}");
    check(s.next(), "magrit");
    check(s.next(), "cat-build");
    check(command, s.hasNext());
    this.repository = createRepository(s.next());
    check(command, s.hasNext());
    checkSha1(sha1 = s.next());

    return this;
  }
Example #23
0
  public void loadInputToModel() {
    Scanner in = new Scanner(this.input);
    String previous;
    if (in.hasNext()) {
      String current = in.next();

      while (in.hasNext()) {
        previous = current;
        current = in.next();

        this.model.addSourceDestination(previous, current);
      }
    }
  }
  public void first() {
    // System.out.println("Inside First. This is called only once");
    java.util.Scanner s = null;

    try {
      s = new java.util.Scanner(new java.io.BufferedReader(new java.io.FileReader("sample")));
      s.useLocale(java.util.Locale.US);
      position = 0;
      while (s.hasNext()) {
        if (s.hasNextLine()) {
          String c = s.nextLine();
          ch[position] = c.charAt(0);
          for (int i = 0; i < 35; i++) {
            Character cha = new Character(c.charAt(i + 1));
            String st = cha.toString();
            data[position][i] = Integer.parseInt(st);
          }
          position++;
        }
      }
    } catch (java.io.IOException ert) {
      javax.swing.JOptionPane.showMessageDialog(
          null, ert, "Error", javax.swing.JOptionPane.ERROR_MESSAGE);
    }

    try {
      s = new java.util.Scanner(new java.io.BufferedReader(new java.io.FileReader("imageload")));
      s.useLocale(java.util.Locale.US);
      while (s.hasNext()) {
        if (s.hasNextLine()) {
          imagedir = s.nextLine();
        }
      }
    } catch (java.io.IOException ert) {
      javax.swing.JOptionPane.showMessageDialog(
          null, ert, "Error", javax.swing.JOptionPane.ERROR_MESSAGE);
    }
    s.close();
    if (imagedir.equals("")) {
      javax.swing.JOptionPane.showMessageDialog(
          null,
          "This must be your first run of Live! Character Recognition.\nPlease set an image folder.",
          "Problem loading image",
          javax.swing.JOptionPane.INFORMATION_MESSAGE);
    } else {
      im.running();
    }
  }
  private static boolean isInteger(String s, int radix) {
    Scanner sc = new Scanner(s.trim());
    if (!sc.hasNextInt(radix)) return false;

    sc.nextInt(radix);
    return !sc.hasNext();
  }
Example #26
0
  /**
   * readFileAndFillArray method. Receives a file and returns an ArrayList filled with the contents
   * of the file.
   *
   * @precondition The file has to exist.
   * @precondition All values should be positive.
   * @postcondition Array filled with pebble weights
   * @param String fileDir file containing the pebbles' weights
   * @param ArrayList<Pebbles> bagContentsPebble empty array representing one of the bags
   * @return ArrayList<Integer> bagContents the filled array representing one of the bags
   * @throws IllegalWeightException
   * @throws FileNotFoundException
   */
  public static ArrayList<Pebbles> readFileAndFillArray(
      String fileDir, ArrayList<Pebbles> bagContentsPebble)
      throws IllegalWeightException, FileNotFoundException {

    // Get scanner instance
    Scanner scanner = new Scanner(new FileReader(fileDir));

    // Set the delimiter used in file
    scanner.useDelimiter(",");

    // Get all tokens and store them a list
    while (scanner.hasNext()) {
      String value = scanner.next();

      // convert to integer and get rid of extra space with trim
      int valueInt = Integer.parseInt(value.trim());

      // check if the weight is valid
      if (valueInt >= 0) {
        bagContentsPebble.add(new Pebbles(valueInt));
      }
      // if the weight is not valid -> warn the user
      else {
        scanner.close();
        throw new IllegalWeightException(null);
      }
    }

    // Do not forget to close the scanner
    scanner.close();

    return bagContentsPebble;
  }
  public static LinkedList<String> readFromFile() {
    File f;
    Scanner scanner;
    LinkedList<String> result = new LinkedList<>();

    try {
      f = new File(fileName);
      scanner = new Scanner(f);
      // Pattern regex = Pattern.compile("\\w");

      while (scanner.hasNext()) {
        String current = scanner.next();
        String[] splitLine = current.split(",");

        for (int i = 0; i < splitLine.length; i++) {
          // Debug statement
          System.out.println("Scanner adding to list:" + splitLine[i]);
          result.add(splitLine[i]);
        }

        System.out.println("Scanner reading:" + current);
        // result.add(current);
        // System.out.println("Output of file" + );
      }

      return result;
    } catch (IOException exc) {
      System.out.println("Error reading file line" + exc.getMessage());
    }
    return null;
  }
Example #28
0
  @Override
  public void run() {
    try {
      host = InetAddress.getLocalHost().getHostName();
      s = new Socket(host, SERVER_PORT);
      output = new PrintWriter(s.getOutputStream(), true);
      input = new Scanner(s.getInputStream());
      output.println(name);

      while (!s.isClosed()) {

        if (input.hasNext()) {
          String msg = input.nextLine();

          if (msg.contains("!%#&")) {
            String tmp = msg.substring(4);
            tmp = tmp.replace("[", "");
            tmp = tmp.replace("]", "");

            String[] users = tmp.split(", ");

            activelist.setListData(users);
          } else {
            history.append(msg + "\n");
          }
        }
      }
    } catch (IOException e) {
      System.out.println(e);
      JOptionPane.showMessageDialog(null, "Unable to connect to the server.");
      System.exit(0);
    }
  }
 @Override
 public int corpusDocFrequencyByTerm(String term) {
   String indexFile = _options._indexPrefix + "/merge.txt";
   try {
     BufferedReader reader = new BufferedReader(new FileReader(indexFile));
     String line;
     while ((line = reader.readLine()) != null) {
       int termDocFren = 0;
       String title = "";
       String data = "";
       Scanner s = new Scanner(line).useDelimiter("\t");
       while (s.hasNext()) {
         title = s.next();
         data = s.next();
       }
       if (title.equals(term)) {
         String[] docs = data.split("\\|");
         termDocFren = docs.length;
       }
       reader.close();
       return termDocFren;
     }
     reader.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
   return 0;
 }
  private int generateIndex(String content, int docid) {
    Scanner s = new Scanner(content); // Uses white space by default.
    int totalcount = 0;
    while (s.hasNext()) {
      ++_totalTermFrequency;
      ++totalcount;
      String token = s.next();
      // decrement the size() by 1 as the real doc id
      // int did=_documents.size()-1;

      Vector<Integer> plist = _index.get(token);
      if (plist != null) {
        if (plist.lastElement() != docid) {
          plist.add(docid);
          _index.put(token, plist);
        }
      } else {
        // _terms.add(token);
        Vector<Integer> p = new Vector<Integer>();
        p.add(docid);
        _index.put(token, p);
      }
    }

    return totalcount;
  }