Пример #1
1
  /**
   * Sets a mnemomic for the specified button.
   *
   * @param b button
   * @param mnem mnemonics that have already been assigned
   */
  public static void setMnemonic(final AbstractButton b, final StringBuilder mnem) {
    // do not set mnemonics for Mac! Alt+key used for special characters.
    if (Prop.MAC) return;

    // find and assign unused mnemomic
    final String label = b.getText();
    final int ll = label.length();
    for (int l = 0; l < ll; l++) {
      final char ch = Character.toLowerCase(label.charAt(l));
      if (!letter(ch) || mnem.indexOf(Character.toString(ch)) != -1) continue;
      b.setMnemonic(ch);
      mnem.append(ch);
      break;
    }
  }
Пример #2
0
 public static void main(String args[]) throws IOException {
   DataInputStream ip = new DataInputStream(System.in);
   String S1 = new String();
   String temp;
   String S2 = new String();
   int i;
   System.out.print("Enter expression : ");
   temp = ip.readLine();
   for (i = 0; i < temp.length(); i++) {
     if (temp.charAt(i) == '*') {
       // System.out.println(temp.substring(0,i)); //i because of gorm [,)
       // System.out.println(temp.substring(i+1,temp.length()));
       S1 = temp.substring(0, i); // i because of gorm [,)
       S2 = temp.substring(i + 1, temp.length());
     }
   }
   int a1[] = new int[100];
   int a2[] = new int[100];
   int k = 0;
   for (i = S1.length() - 1; i >= 0; i--) {
     String temp2 = Character.toString(S1.charAt(i));
     a1[99 - k] = Integer.parseInt(temp2);
     k++;
   }
   k = 0;
   for (i = S2.length() - 1; i >= 0; i--) {
     String temp2 = Character.toString(S2.charAt(i));
     a2[99 - k] = Integer.parseInt(temp2);
     k++;
   }
   int a3[] = new int[100];
   /*
    * write multiplication code here
    */
   int temp3 = 0;
   for (i = 99; i > 99 - S1.length(); i--) // change here
   {
     int temp2 = a1[i] * a2[99] + temp3;
     temp3 =
         0; // addition to correct code since it was not being set to zero it was causing errors
     if (temp2 < 10
         || i == 99 - S1.length() + 1) // change made here so that if last result is >=10
     { // it should be written directly
       a3[i] = temp2;
     } else {
       a3[i] = temp2 % 10;
       temp3 = ((temp2 - temp2 % 10) / 10); // unneccessary+a3[i-1];
     }
   }
   for (i = 0; i < 100; i++) {
     System.out.print(a3[i]);
   }
 }
Пример #3
0
  public static void findTExtLetters(String letterToFind, String filePath) throws IOException {

    BufferedReader br = new BufferedReader(new FileReader(new File(filePath)));
    boolean foundIt = false;
    int i = 1;
    String[] letterToFindarray = letterToFind.split("");

    for (String line = br.readLine(); line != null; line = br.readLine()) {

      String[] letterarray = line.split("");

      for (int j = 0; j < letterarray.length; j++) {
        for (int x = 0; x < letterToFindarray.length; x++) {
          if (letterToFindarray[x].equals(letterarray[j])) {
            System.out.println("Egyezes a(z)" + i + ". sor, " + (j + 1) + ". karakterrel");
            foundIt = true;
          } else {
            char m = letterToFindarray[x].charAt(0);
            int o = (int) m;
            if (o < 95) { // nagy betűt keresek és kis betű a keresendőben
              char n = letterarray[j].charAt(0);
              int p = (int) n;
              p = p - 32;
              n = (char) p;
              String backToString = Character.toString(n);
              if (letterToFindarray[x].equals(backToString)) {
                System.out.println("Egyezes a(z)" + i + ". sor, " + (j + 1) + ". karakterrel");
                foundIt = true;
              }
            } else { //// kis betűt keresek és nagy betű a keresendőben
              char n = letterarray[j].charAt(0);
              int p = (int) n;
              p = p + 32;
              n = (char) p;
              String backToString = Character.toString(n);
              if (letterToFindarray[x].equals(backToString)) {
                System.out.println("Egyezes a(z)" + i + ". sor, " + (j + 1) + ". karakterrel");
                foundIt = true;
              }
            }
          }
        }
      }
      i++;
    }
    if (!foundIt) {
      System.out.println("Nincs ilyen szo");
    }
  }
Пример #4
0
  private String ask(String cmd) {
    BufferedWriter out = null;
    BufferedReader in = null;
    Socket sock = null;
    String ret = "";
    try {
      System.out.println(server);
      sock = new Socket(server, ServerListener.PORT);
      out = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));
      out.write(cmd, 0, cmd.length());
      out.flush();
      in = new BufferedReader(new InputStreamReader(sock.getInputStream()));
      int inr = in.read();
      while (inr != ';') {
        ret += Character.toString((char) inr);
        inr = in.read();
      }
    } catch (IOException io) {
      io.printStackTrace();
    } finally {
      try {
        out.close();
        in.close();
        sock.close();
      } catch (IOException io) {
        io.printStackTrace();
      }
    }

    return ret;
  }
Пример #5
0
  private void fixTabs(int tabSize) {

    int rowIndex = 0;

    for (StringBuilder row1 : rows) {
      String row = row1.toString();
      StringBuilder newRow = new StringBuilder();

      char[] chars = row.toCharArray();
      for (char c : chars) {
        if (c == '\t') {
          int spacesLeft = tabSize - newRow.length() % tabSize;
          if (DEBUG) {
            System.out.println("Found tab. Spaces left: " + spacesLeft);
          }
          String spaces = StringUtils.repeatString(" ", spacesLeft);
          newRow.append(spaces);
        } else {
          String character = Character.toString(c);
          newRow.append(character);
        }
      }
      rows.set(rowIndex, newRow);
      rowIndex++;
    }
  }
Пример #6
0
 private void invalidNamedArgument(String[] args) throws ArgumentDoesNotExistException {
   for (int i = 0; i < args.length; i++) {
     if (args[i].startsWith("--")) {
       String[] splitLongNamedArg = new String[2];
       splitLongNamedArg = args[i].split("--");
       NamedArgument tempArg = getNamedArgument(splitLongNamedArg[1]);
       if (tempArg == null) {
         invalidNamedArgument = splitLongNamedArg[1];
         throw new ArgumentDoesNotExistException(
             argumentDoesNotExistMessage(invalidNamedArgument));
       }
     } else if (args[i].startsWith("-")) {
       String[] splitShortNamedArg = new String[2];
       splitShortNamedArg = args[i].split("-");
       if (splitShortNamedArg[1].length() == 1) { // single char
         NamedArgument tempArg = getNamedArgument(splitShortNamedArg[1].charAt(0));
         if (tempArg == null) {
           invalidNamedArgument = splitShortNamedArg[1];
           throw new ArgumentDoesNotExistException(
               argumentDoesNotExistMessage(invalidNamedArgument));
         }
       } else {
         for (int k = 0; k < splitShortNamedArg[1].length(); k++) {
           NamedArgument tempArg = getNamedArgument(splitShortNamedArg[1].charAt(k));
           if (tempArg == null) {
             invalidNamedArgument = Character.toString(splitShortNamedArg[1].charAt(k));
             throw new ArgumentDoesNotExistException(
                 argumentDoesNotExistMessage(invalidNamedArgument));
           }
         }
       }
     }
   }
 }
Пример #7
0
  /** @return Expr */
  Expr read() {
    try {
      while (_tokens.nextToken() != _tokens.TT_EOF) {
        if (_tokens.ttype == -2) {
          Numeral a = new Numeral(_tokens.nval);
          return a;
        } else if (_tokens.ttype == -3) {
          String a = new String(_tokens.sval);
          return new Symbol(a);
        } else if (_tokens.ttype == (int) '(') {
          _tokens.nextToken();
          String s;
          if (_tokens.ttype == -3) {
            s = _tokens.sval;
          } else {
            s = Character.toString((char) _tokens.ttype);
          }
          System.out.println("operator: " + s);
          return Combination.create(s, getOperands());
        }
      }
    } catch (IOException e) {
      System.err.println("error: " + e.getMessage());
      System.exit(1);
    }
    System.out.println("end of file reached");

    return null;
  }
Пример #8
0
 /** Ensures an arc's label is indeed printable (dot uses US-ASCII). */
 private static String printableLabel(int label) {
   if (label >= 0x20 && label <= 0x7d) {
     return Character.toString((char) label);
   } else {
     return "0x" + Integer.toHexString(label);
   }
 }
Пример #9
0
 /**
  * finds all possible separation chars
  *
  * @param lineWithAttributes
  * @return
  */
 protected HashMap<String, Integer> getSeparationCandidates(String lineWithAttributes) {
   HashMap<String, Integer> result = new HashMap<>();
   String s;
   for (char c : lineWithAttributes.toCharArray()) {
     s = Character.toString(c);
     Map.add(result, s, 1);
   }
   return result;
 }
  private static void findMines(int r, int c) {
    for (int x = 0; x < r; x++) {
      for (int y = 0; y < c; y++) {

        if (currentMap[x][y] == '*') printedMap[x][y] = Character.toString(currentMap[x][y]);
        else printedMap[x][y] = countSurrounding(x, y, r, c);
      }
    }
  }
Пример #11
0
  protected final String getQuoteCharacter(TableDefinition tableDefinition) {
    String quoteCharVal = tableDefinition.getProperty("quotechar", this.getDefaultQuoteCharVal());

    if (quoteCharVal.equals("")) {
      return "";
    } else {
      return Character.toString((char) Integer.valueOf(quoteCharVal).intValue());
    }
  }
Пример #12
0
 /*
     this method draws a board(not the screen). if
     the first parameter is true, an example board
     (filled with numbers) is drawn. false draws a
     board filled with moves[]
 */
 public static void drawBoard(boolean example, char[] moves) {
   for (int i = 0; i < 9; i++) {
     System.out.print(example ? i + 1 : Character.toString(moves[i]));
     if (i == 2 || i == 5) {
       System.out.println();
       System.out.println("---------");
     } else if (i != 8) System.out.print(" | ");
   }
 }
Пример #13
0
 /**
  * Outputs this <code>State</code> as though it came from the text input file.
  *
  * @return a <code>String</code> describing this <code>State</code>.
  */
 public String toString() {
   return STATE
       + " "
       + Integer.toString(index)
       + " "
       + Character.toString(c)
       + " "
       + Integer.toString(qtrue)
       + " "
       + Integer.toString(qfalse);
 }
Пример #14
0
 public static String getRandomPwd() {
   Random rd = new Random();
   String n = "";
   int getNum;
   do {
     getNum = Math.abs(rd.nextInt()) % 10 + 48; // 产生数字0-9的随机数
     // getNum = Math.abs(rd.nextInt())%26 + 97;//产生字母a-z的随机数
     char num1 = (char) getNum;
     String dn = Character.toString(num1);
     n += dn;
   } while (n.length() < 8);
   return n;
 }
Пример #15
0
 private boolean asciiEqual(String[] letterToFindarray, String[] letterarray, int stepcount) {
   char m = letterToFindarray[stepcount].charAt(0);
   int o = (int) m;
   char n = letterarray[stepcount].charAt(0);
   int p = (int) n;
   if (o < 95) { // nagy betűt keresek és kis betű a keresendőben
     p = p - 32;
   } else { //// kis betűt keresek és nagy betű a keresendőben
     p = p + 32;
   }
   n = (char) p;
   String backToString = Character.toString(n);
   return letterToFindarray[stepcount].equals(backToString);
 }
Пример #16
0
 /**
  * This util method is used to retrieve the string tokens resides in a particular udt parameter.
  *
  * @param param Name of the parameter
  * @return
  */
 public static Queue<String> getTokens(String param) {
   boolean isString = false;
   Queue<String> tokens = new LinkedBlockingQueue<String>();
   char[] chars = param.toCharArray();
   StringBuilder columnName = new StringBuilder();
   for (int i = 0; i < chars.length; i++) {
     Character c = chars[i];
     if (!".".equals(c.toString()) && !"[".equals(c.toString()) && !"]".equals(c.toString())) {
       isString = true;
       columnName.append(c.toString());
       if (i == chars.length - 1) {
         tokens.add(columnName.toString());
       }
     } else {
       if (isString) {
         tokens.add(columnName.toString());
         columnName = new StringBuilder();
         isString = false;
       }
       tokens.add(c.toString());
     }
   }
   return tokens;
 }
Пример #17
0
  // Initialize Board
  public void init() {
    // Create cells and handlers
    cells = new JTextField[gameBoard.boardSize * gameBoard.boardSize + 1];

    // Redraw Panel
    boardPanel.removeAll();
    boardPanel.setLayout(new GridLayout(gameBoard.boardSize, gameBoard.boardSize)); // Set layout

    JTextFilter TextFilter = new JTextFilter(3);
    JTextDocumentListener JTextDocFilter = new JTextDocumentListener();

    for (int i = 1; i <= gameBoard.boardSize * gameBoard.boardSize; i++) {
      cells[i] = new JTextField();

      ((AbstractDocument) cells[i].getDocument()).setDocumentFilter(TextFilter);
      ((AbstractDocument) cells[i].getDocument()).addDocumentListener(JTextDocFilter);
      ((AbstractDocument) cells[i].getDocument()).putProperty("index", i);

      cells[i].setHorizontalAlignment(JTextField.CENTER);
      cells[i].setFont(new Font("Agency FB", Font.BOLD, 24));

      // Add elements to the grid content pane
      boardPanel.add(cells[i]);
    }

    // Initialize booleans
    gameOver = false;

    // Clear Board
    for (int i = 1; i <= (gameBoard.boardSize * gameBoard.boardSize); i++) {
      String ch = Integer.toString(this.gameBoard.cells[i]);
      char chr = '-';
      if (ch.compareTo("0") == 0 || ch == Character.toString(chr)) {
        cells[i].setText("");
      } else {
        cells[i].setText(ch);
        cells[i].setBackground(Color.lightGray);
      }
    }
    // gameBoard.out();

    setVisible(true);
    this.boardPanel.repaint();

    this.gameTimer.reset();
    jButtonSOLVE.setEnabled(true);
  }
 public static ArrayList<String> validateSamplesDirectoryStructureIdentifyVersions(
     String samplesDirPath, ArrayList<String> versionArr) {
   String samplesDir[] = getDirectoryNames(samplesDirPath);
   StringBuilder builder = new StringBuilder();
   ArrayList<String> tempArr = new ArrayList<String>();
   Pattern numeric = Pattern.compile("[0-9_.-]");
   for (String dir : samplesDir) {
     for (int item = dir.length() - 1; item >= 0; item--) {
       char singleChar = dir.charAt(item);
       Matcher matcher = numeric.matcher(Character.toString(singleChar));
       // Find all matches
       if (matcher.find()) {
         // Get the matching string
         builder.append(singleChar);
       } else {
         if (builder.length() > 1) {
           tempArr.add(builder.toString());
           builder.setLength(0);
         } else {
           builder.setLength(0);
         }
       }
       if (item == 0 && builder.length() != 0) {
         tempArr.add(builder.toString());
         builder.setLength(0);
       }
     }
     int max;
     int previousMax = 0;
     String[] version = new String[1];
     for (String element : tempArr) {
       max = element.length();
       if (max > previousMax) {
         previousMax = max;
         version[0] = element;
       }
     }
     if (version[0] != null) {
       if (version[0].length() >= 2) {
         versionArr.add(dir);
       }
     }
     tempArr.clear();
   }
   return versionArr;
 }
 private Map<Character, Double> normalizeSymbolMap(Map<Character, Double> letterFrequency) {
   Double freq;
   Double mostFrequent = new Double(0);
   Character textCharacter;
   Set symbolsInMap = letterFrequency.entrySet();
   Iterator iterateSymbols = symbolsInMap.iterator();
   while (iterateSymbols.hasNext()) {
     Map.Entry symbolEntries = (Map.Entry) iterateSymbols.next();
     textCharacter = (Character) symbolEntries.getKey();
     freq = letterFrequency.get(textCharacter);
     letterFrequency.put(textCharacter, (freq / text.length()));
     if (freq != null && freq > mostFrequent) {
       mostFrequent = freq;
       mostFrequentLetter = textCharacter.toString();
     }
   }
   mostFrequentLetterFrequency = mostFrequent / text.length();
   return letterFrequency;
 }
Пример #20
0
 private ArrayList<String> getPositionalArgs(String[] args) {
   ArrayList<String> posArgList = new ArrayList<String>();
   for (int i = 0; i < args.length; i++) { // going through args from CLI
     if (!args[i].startsWith("-") && i == 0) { // test if the first arg is a positional arg
       posArgList.add(args[i]);
     } else if (!args[i].startsWith("-")) { // arg from CLI doesn't have a dash
       if (!args[i - 1].startsWith(
           "-")) { // if the one before it doesn't have a dash, then it's a pos arg
         posArgList.add(args[i]);
       } else {
         String[] tempNamedArg = new String[2];
         if (args[i - 1].startsWith("--")) {
           tempNamedArg = args[i - 1].split("--");
           for (int j = 0; j < namedArgumentList.size(); j++) { // g
             NamedArgument currentNamedArg = namedArgumentList.get(j);
             if (currentNamedArg.getName().equals(tempNamedArg[1])) {
               if (currentNamedArg.getType().equals("boolean")) { // to pos args
                 posArgList.add(args[i]);
               }
             }
           }
         } else {
           tempNamedArg = args[i - 1].split("-");
           if (tempNamedArg[1].length() == 1) {
             for (int j = 0; j < namedArgumentList.size(); j++) {
               NamedArgument currentNamedArg = namedArgumentList.get(j);
               if (Character.toString(currentNamedArg.getShortFormName())
                   .equals(tempNamedArg[1])) {
                 if (currentNamedArg.getType().equals("boolean")) {
                   posArgList.add(args[i]);
                 }
               }
             }
           } else {
             posArgList.add(args[i]);
           }
         }
       }
     }
   }
   return posArgList;
 }
Пример #21
0
  @EventHandler
  public void onTick(TickEvent event) {
    if (!bot.hasSpawned() || !bot.isConnected()) return;
    if (tickDelay > 0) {
      tickDelay--;
      return;
    }

    MainPlayerEntity player = bot.getPlayer();
    if (player == null || !bot.hasSpawned() || spamMessage == null) return;
    if (nextMessage > 0) {
      nextMessage--;
      return;
    }
    try {
      String message = spamMessage;
      MessageFormatter formatter = new MessageFormatter();
      synchronized (bots) {
        if (bots.size() > 0) {
          DarkBotMCSpambot bot = bots.get(++nextBot >= bots.size() ? nextBot = 0 : nextBot);
          if (bot != null && bot.bot != null && bot.bot.getSession() != null)
            formatter.setVariable("bot", bot.bot.getSession().getUsername());
        }
      }
      if (spamList.length > 0) {
        formatter.setVariable(
            "spamlist",
            spamList[++nextSpamList >= spamList.length ? nextSpamList = 0 : nextSpamList]);
      }
      formatter.setVariable("rnd", Util.generateRandomString(15 + random.nextInt(6)));
      formatter.setVariable(
          "msg",
          Character.toString(
              msgChars[++nextMsgChar >= msgChars.length ? nextMsgChar = 0 : nextMsgChar]));
      message = formatter.format(message);
      bot.say(message);
    } catch (Exception e) {
      e.printStackTrace();
    }
    nextMessage = messageDelay;
  }
Пример #22
0
  /**
   * Calculates the phone list for a given word. If a phone list cannot be determined, <code>null
   * </code> is returned. This particular implementation ignores the part of speech.
   *
   * @param word the word to find
   * @param partOfSpeech the part of speech.
   * @return the list of phones for word or <code>null</code>
   */
  public String[] getPhones(String word, String partOfSpeech) {
    if (RiTa.PRINT_LTS_INFO && !RiTa.SILENT)
      System.out.println("[INFO] Using LTS for '" + word + "'");

    List phoneList = new ArrayList();
    State currentState;
    Integer startIndex;
    int stateIndex;
    char c;

    // Create "000#word#000"
    char[] full_buff = getFullBuff(word);

    // For each character in the word, create a WINDOW_SIZE
    // context on each size of the character, and then ask the
    // state machine what's next. Its magic
    for (int pos = 0; pos < word.length(); pos++) {
      for (int i = 0; i < WINDOW_SIZE; i++) {
        fval_buff[i] = full_buff[pos + i];
        fval_buff[i + WINDOW_SIZE] = full_buff[i + pos + 1 + WINDOW_SIZE];
      }
      c = word.charAt(pos);
      startIndex = (Integer) letterIndex.get(Character.toString(c));
      if (startIndex == null) {
        continue;
      }

      stateIndex = startIndex.intValue();
      currentState = getState(stateIndex);
      while (!(currentState instanceof FinalState)) {
        stateIndex = ((DecisionState) currentState).getNextState(fval_buff);
        currentState = getState(stateIndex);
      }

      ((FinalState) currentState).append((ArrayList) phoneList);
      // RiTa.out("phoneList: "+phoneList);
    }

    return (String[]) phoneList.toArray(new String[0]);
  }
Пример #23
0
  private void setShortFormNamedArgValues(String[] args) throws NumberFormatException {
    for (int i = 0; i < args.length; i++) {
      String[] tempNamedArg = new String[2];
      if (args[i].startsWith("-")) {
        tempNamedArg = args[i].split("-");
        for (int k = 0; k < namedArgumentList.size(); k++) {
          incorrectDataTypeIndex = k;
          incorrectArgumentType = "named";
          NamedArgument currentNamedArg = namedArgumentList.get(k);
          if (tempNamedArg[1].length() == 1) { // single char
            if (Character.toString(currentNamedArg.getShortFormName()).equals(tempNamedArg[1])) {
              if (!currentNamedArg.getType().equals("boolean")) {
                incorrectArgValueForSpecifiedDataType = args[i + 1];
                if (currentNamedArg.getType().equals("integer")) {
                  int argValue = Integer.parseInt(args[i + 1]);
                  currentNamedArg.setValue(args[i + 1]);
                } else if (currentNamedArg.getType().equals("float")) {
                  float argValue = Float.parseFloat(args[i + 1]);
                  currentNamedArg.setValue(args[i + 1]);
                } else if (currentNamedArg.getType().equals("string")) {
                  currentNamedArg.setValue(args[i + 1]);
                }

              } else {
                currentNamedArg.setValue("true");
              }
            }
          } else { // multiple flags in one specification
            for (int j = 0; j < tempNamedArg[1].length(); j++) {
              if (currentNamedArg.getShortFormName() == tempNamedArg[1].charAt(j)) {
                currentNamedArg.setValue("true");
              }
            }
          }
        }
      }
    }
  }
 /**
  * Writes the r-field of an instruction in the form "l<I>reg</I>r", where l and r are the bracket
  * characters to use.
  *
  * @param leftbracket the character to print before the register.
  * @param r the number of the register.
  * @param rightbracket the character to print after the register.
  */
 private void writeR(char leftbracket, int r, char rightbracket) {
   asmWrite(Character.toString(leftbracket));
   asmWrite(Machine.intToReg[r].toString());
   asmWrite(Character.toString(rightbracket));
 }
Пример #25
0
  public boolean readSrecCode(String fName) {

    FileInputStream fis = null;

    srec = new short[SREC_MAX_LINES][PKT_PAYLOAD_SIZE];
    numLines = 1;
    numPkts = 0;

    try {
      BufferedReader dis =
          new BufferedReader(new InputStreamReader(fis = new FileInputStream(fName)));
      System.out.println("--------------------------------------------------");
      System.out.println("Reading file: " + fName);
      // WARNING
      int curByte = 0; // 16; // account for S0 line which is not parsed

      while (true) {
        char bline[] = dis.readLine().toUpperCase().toCharArray();
        if (bline[1] == '1') {
          numLines++;
          if (bline.length > SREC_MAX_LINE_LEN) {
            System.out.println("ERROR: SREC Read: Too many byes on line: " + numLines);
            return false;
          }
          // srec length
          int length =
              Integer.parseInt(Character.toString(bline[2]) + Character.toString(bline[3]), 16) - 3;

          // data
          for (int i = 0, j = 8; i < length; i++, j += 2) {
            if (curByte >= PKT_PAYLOAD_SIZE) {
              numPkts++;
              curByte = 0;
            }
            srec[numPkts][curByte++] =
                (short)
                    Integer.parseInt(
                        Character.toString(bline[j]) + Character.toString(bline[j + 1]), 16);
            imgSize++;
          }
        } else if (bline[1] == '2') {
          numLines++;
          if (bline.length > SREC_MAX_LINE_LEN) {
            System.out.println("ERROR: SREC Read: Too many byes on line: " + numLines);
            return false;
          }
          // srec length
          int length =
              Integer.parseInt(Character.toString(bline[2]) + Character.toString(bline[3]), 16) - 4;

          // data
          for (int i = 0, j = 10; i < length; i++, j += 2) {
            if (curByte >= PKT_PAYLOAD_SIZE) {
              numPkts++;
              curByte = 0;
            }
            srec[numPkts][curByte++] =
                (short)
                    Integer.parseInt(
                        Character.toString(bline[j]) + Character.toString(bline[j + 1]), 16);
            imgSize++;
          }
        }
      }
    } catch (FileNotFoundException e) {
      System.out.println("ERROR: (SREC Read) " + e);
      return false;
    } catch (Exception e) {
      numPgs = (short) (((imgSize - 1) / BYTES_PER_PAGE) + 1);
      System.out.println(
          "Read END: (Lines="
              + numLines
              + ",Pages="
              + numPgs
              + ",Pkts="
              + numPkts
              + ",Size="
              + imgSize
              + ")");
      System.out.println("--------------------------------------------------");
    }

    try {
      if (fis != null) fis.close();
    } catch (Exception e) {
      e.printStackTrace();
    }

    return true;
  }
Пример #26
0
  private void blockDataFile(DataFile dataFile, RetailerSite retailerSite, int blockSize) {
    File filePath = null;
    PreprocessorHandlerContext context = null;

    try {
      dataFile.setStartTime(new Date());

      // TODO srfisk 2012/07/31 Only split CSV, might split images zip
      // when they are very large.
      if (dataFile.getImportType().compareTo(ImportType.images_zip.getTableName()) != 0) {
        filePath = configurationService.getFileSystem().getDirectory(dataFile.getFilePath(), true);

        TableDefinition tableDefinition = this.getTableDefinition(retailerSite, dataFile);

        ImportType importType = ImportType.getTypeFromTableName(dataFile.getImportType());

        String encoding = this.getDataImportEncoding(tableDefinition, filePath);

        String separator =
            Character.toString(
                (char) Integer.valueOf(tableDefinition.getProperty("separator", "9")).intValue());
        String quotechar = this.getQuoteCharacter(tableDefinition);

        int blockCount = 1;
        int totalRowCount = 0;
        boolean noSplit = false;
        boolean done = false;
        context =
            this.createContext(
                retailerSite, dataFile, filePath, tableDefinition, encoding, separator, quotechar);
        while (!done) {
          context.startWriters(blockCount);
          context.writeHeader();

          Row row = null;

          while ((row = context.reader.readNext()) != null && context.rowCount < blockSize) {
            context.writeRow(row);
          }
          context.closeWriters();
          blockCount++;

          if (context.isEmptyBlock()) {
            done = true;
            continue;
          }

          context.createDataFiles(
              retailerSite, importType.getTableName(), importType.getPriority());

          context.inQueueDataFiles();
        }

        dataFile.setHost(null);
        dataFile.setNumRows(totalRowCount);

        if (!noSplit) {
          dataFile.setEndDate(new Date());
          dataFile.setEndTime(new Date());
          dataFile.setStatus(this.getEndStatus());
        } else {
          dataFile.setStatus(FileStatus.IN_QUEUE);
        }
      } else {
        dataFile.setHost(null);
        dataFile.setStatus(FileStatus.IN_QUEUE);
      }

      dataFileRepository.update(dataFile);
    } catch (IOException e) {
      logger.error(String.format("Failed to reading %s data file", filePath), e);
      dataFile.setStatus(FileStatus.ERROR_READ);
      dataFileRepository.update(dataFile);
    } catch (CSVReaderException e) {
      logger.error(String.format("Failed to reading %s data file", filePath), e);
      dataFile.setStatus(FileStatus.ERROR_WRITE);
      dataFileRepository.update(dataFile);
    } catch (CSVWriterException e) {
      logger.error(String.format("Failed to reading %s data file", filePath), e);
      dataFile.setStatus(FileStatus.ERROR_READ);
      dataFileRepository.update(dataFile);
    } catch (Throwable t) {
      logger.error(String.format("Failed to unknown %s data file", filePath), t);
      dataFile.setStatus(FileStatus.ERROR_UNKNOWN);
      dataFileRepository.update(dataFile);
    } finally {
      if (context != null) {
        try {
          context.cleanup();
        } catch (IOException e) {
          // Ignore, did everything we could to close it.
        }
      }
    }
  }
Пример #27
0
 private String firstCharToUpperCase(String name) {
   return Character.toString(Character.toUpperCase(name.charAt(0))) + name.substring(1);
 }
 public static void identifyDuplicateJars(
     List<File> jarFileListInDistribution,
     File distributionVersion,
     HashSet<String> distributionDuplicateJarList,
     ArrayList<String> unidentifiedVersionJars) {
   Iterator<File> itJarList = jarFileListInDistribution.iterator();
   ArrayList<String> tempArr = new ArrayList<String>();
   ArrayList<File> pathListForAddedJarToJarVersions = new ArrayList<File>();
   HashMap<String, String> jarVersions = new HashMap<String, String>();
   StringBuilder builder = new StringBuilder();
   Pattern numeric = Pattern.compile("[^0-9_.-]");
   Pattern nonNumeric = Pattern.compile("[a-zA-Z]");
   while (itJarList.hasNext()) {
     File jarFilePath = itJarList.next();
     String jarName = (jarFilePath).getName();
     if (!jarFilePath
         .getAbsolutePath()
         .contains(
             distributionVersion.getName().replaceAll(".zip", "")
                 + File.separator
                 + TEMP_DIRECTORY
                 + File.separator)) {
       for (int letter = jarName.length() - 1; letter >= 0; letter--) {
         char singleChar = jarName.charAt(letter);
         Matcher matcher = numeric.matcher(Character.toString(singleChar));
         // Find all matches
         if (!matcher.find()) {
           // Get the matching string
           builder.append(singleChar);
         } else if (nonNumeric.matcher(Character.toString(singleChar)).find()) {
           if (builder.length() > 1) {
             tempArr.add(builder.toString());
             builder.setLength(0);
           } else {
             builder.setLength(0);
           }
         }
       }
       int max;
       int previousMax = 0;
       String[] version = new String[1];
       for (String element : tempArr) {
         max = element.length();
         if (max > previousMax) {
           previousMax = max;
           version[0] = element;
         }
       }
       tempArr.clear();
       if (version[0] != null) {
         String jar = jarName.split((StringUtils.reverse(version[0])))[0];
         if (jar.length() >= 2) {
           if (jarVersions.containsKey(jar)) {
             if (!jarVersions.get(jar).equals(jarName.split(jar)[1])) {
               // removing patches - plugins duplication
               if (distributionDuplicateJarList.toString().contains(jarName)) {
                 for (String itemDistributionDuplicateJarList : distributionDuplicateJarList) {
                   if (itemDistributionDuplicateJarList.contains(jarName)
                       && (itemDistributionDuplicateJarList.contains("patches")
                           || itemDistributionDuplicateJarList.contains("plugins"))) {
                     if (!(jarFilePath.getAbsolutePath().contains("patches")
                         || jarFilePath.getAbsolutePath().contains("plugins"))) {
                       distributionDuplicateJarList.add(jarFilePath.getAbsolutePath());
                     }
                   }
                 }
               } else {
                 distributionDuplicateJarList.add(jarFilePath.getAbsolutePath());
               }
               for (File pathListForAddedJarToJarVersion : pathListForAddedJarToJarVersions) {
                 String path = pathListForAddedJarToJarVersion.toString();
                 if (path.contains(jar + jarVersions.get(jar))) {
                   distributionDuplicateJarList.add(path);
                   break;
                 }
               }
             }
           } else {
             jarVersions.put(jar, jarName.split(jar)[1]);
             pathListForAddedJarToJarVersions.add(jarFilePath);
           }
         } else {
           log.info("Unable to identify the version " + jar);
           unidentifiedVersionJars.add(jarFilePath.getAbsolutePath());
         }
       } else {
         jarVersions.put(jarName, null);
         pathListForAddedJarToJarVersions.add(jarFilePath);
       }
     }
   }
 }
Пример #29
0
 /**
  * Writes the given char in XML format. <br>
  * <b>Note: Java specific type</b>
  *
  * @param c to write
  */
 public void writeChar(char c) {
   this.writeValue(CharacterStrategy.NAME, Character.toString(c));
 }
Пример #30
0
  public void nextLex() throws ParseException, IOException {
    token = "";
    char currentChar;
    int currentCharAsInt;

    skipComments();
    skipWhiteSpace();

    try {
      currentCharAsInt = input.read();
    } catch (IOException e1) {
      throw new ParseException(0);
    }

    currentChar = (char) currentCharAsInt;
    if (currentCharAsInt == -1 || currentCharAsInt == EOF_RETURN) {
      token = "<eof>";
      tokenType = endOfInput;
    } else if (Character.isDigit(currentChar)) {
      tokenType = intToken; // by default
      token = token + currentChar;
      while (true) {
        try {
          currentChar = (char) input.read();
        } catch (IOException e) {
          throw new ParseException(0);
        }
        if (Character.isDigit(currentChar)) {
          token = token + currentChar;
        } else if (currentChar == '.') {
          if (token.indexOf('.') == -1) {
            tokenType = realToken;
            token = token + currentChar;
          } else {
            try {
              input.unread(currentChar);
            } catch (IOException e) {
              throw new ParseException(0);
            }
            break;
          }
        } else {
          try {
            input.unread(currentChar);
          } catch (IOException e) {
            throw new ParseException(0);
          }
          break;
        }
      }
    } else if (Character.isLetter(currentChar)) {
      token = token + currentChar;
      while (true) {
        try {
          currentChar = (char) input.read();
        } catch (IOException e) {
          throw new ParseException(0);
        }
        if (Character.isLetterOrDigit(currentChar)) {
          token = token + currentChar;
        } else {
          input.unread(currentChar);
          tokenType = identifierToken;
          for (String current : keywords) {
            if (match(current)) {
              tokenType = keywordToken;
              break;
            }
          }
          break;
        }
      }
    } else {
      switch (currentChar) {
        case '"':
          tokenType = stringToken;
          while (true) {
            try {
              currentCharAsInt = input.read();
              currentChar = (char) currentCharAsInt;
            } catch (IOException e) {
              throw new ParseException(0);
            }
            if (currentCharAsInt == -1 || currentCharAsInt == EOF_RETURN) {
              throw new ParseException(2);
            } else if (currentChar == '"') {
              break;
            }
            token = token + currentChar;
          }
          break;

        case '<':
          tokenType = otherToken;
          token = token + currentChar;
          char secondChar = (char) input.read();
          if (secondChar == '<') {
            token = token + secondChar;
            break;
          } else {
            input.unread(secondChar);
          }

        case '>':
        case '=':
        case '!':
          tokenType = otherToken;
          if (currentChar != '<') {
            token = token + currentChar;
          }
          secondChar = (char) input.read();
          if (secondChar == '=') {
            token = token + secondChar;
            break;
          } else {
            input.unread(secondChar);
          }
          break;

        default:
          token = Character.toString(currentChar);
          tokenType = otherToken;
      }
    }
    return;
  }