/** Saves the authorization database to disk. */
 public void save() throws CoreException {
   if (!needsSaving || file == null) return;
   try {
     file.delete();
     if ((!file.getParentFile().exists() && !file.getParentFile().mkdirs())
         || !canWrite(file.getParentFile()))
       throw new CoreException(
           new Status(
               IStatus.ERROR,
               Platform.PI_RUNTIME,
               Platform.FAILED_WRITE_METADATA,
               NLS.bind(Messages.meta_unableToWriteAuthorization, file),
               null));
     file.createNewFile();
     FileOutputStream out = new FileOutputStream(file);
     try {
       save(out);
     } finally {
       out.close();
     }
   } catch (IOException e) {
     throw new CoreException(
         new Status(
             IStatus.ERROR,
             Platform.PI_RUNTIME,
             Platform.FAILED_WRITE_METADATA,
             NLS.bind(Messages.meta_unableToWriteAuthorization, file),
             e));
   }
   needsSaving = false;
 }
  private static FileItem prepareFileItemFromInputStream(
      PipelineContext pipelineContext, InputStream inputStream, int scope) {
    // Get FileItem
    final FileItem fileItem = prepareFileItem(pipelineContext, scope);
    // Write to file
    OutputStream os = null;
    try {
      os = fileItem.getOutputStream();
      copyStream(inputStream, os);
    } catch (IOException e) {
      throw new OXFException(e);
    } finally {
      if (os != null) {
        try {
          os.close();
        } catch (IOException e) {
          throw new OXFException(e);
        }
      }
    }
    // Create file if it doesn't exist (necessary when the file size is 0)
    final File storeLocation = ((DiskFileItem) fileItem).getStoreLocation();
    try {
      storeLocation.createNewFile();
    } catch (IOException e) {
      throw new OXFException(e);
    }

    return fileItem;
  }
  public static void writeByteBuffer(ByteBuffer bbuf, String filename) {
    // Write bbuf to filename
    File file;
    try {
      // Get log file
      String logfile = "C:\\" + filename + ".txt";
      file = new File(logfile);
      boolean exists = file.exists();
      if (!exists) {
        // create a new, empty node file
        try {
          file = new File(logfile);
          boolean success = file.createNewFile();
        } catch (IOException e) {
          System.out.println("Create Event Log file failed!");
        }
      }
      try {
        // Create a writable file channel
        FileChannel wChannel = new FileOutputStream(file, true).getChannel();
        // Write the ByteBuffer contents; the bytes between the ByteBuffer's
        // position and the limit is written to the file
        wChannel.write(bbuf);

        // Close the file
        wChannel.close();
      } catch (IOException e) {
      }
    } catch (java.lang.Exception e) {
    }
  }
 public static void writeLogFile(String descript, String filename) {
   File file;
   FileOutputStream outstream;
   // BufferedWriter outstream;
   Date time = new Date();
   long bytes = 30000000;
   try {
     // Get log file
     String logfile = "C:\\" + filename + ".txt";
     file = new File(logfile);
     boolean exists = file.exists();
     if (!exists) {
       // create a new, empty node file
       try {
         file = new File(logfile);
         boolean success = file.createNewFile();
       } catch (IOException e) {
         System.out.println("Create Event Log file failed!");
       }
     }
     try {
       descript = descript + "\n";
       outstream = new FileOutputStream(file, true);
       for (int i = 0; i < descript.length(); ++i) {
         outstream.write((byte) descript.charAt(i));
       }
       outstream.close();
     } catch (IOException e) {
     }
   } catch (java.lang.Exception e) {
   }
 }
Beispiel #5
0
  /**
   * Load the database from the database file given in "database.json" if the file doesn't exist, it
   * gets created here if the file has a database in it already, it is loaded here
   *
   * @return false if there is an error opening the database
   */
  public boolean open() {
    try {
      System.out.println(dbPath);
      File dbFile = new File(dbPath);

      // Only read the database from the file if it exists
      if (dbFile.exists()) {
        FileInputStream fileIn = new FileInputStream(dbPath);
        ObjectInputStream in = new ObjectInputStream(fileIn);
        // load the database here
        database = (HashMap<K, V>) in.readObject();
        // make sure the streams close properly
        in.close();
        fileIn.close();

        Debug.println("Database loaded");
      } else {
        dbFile.getParentFile().mkdirs();
        dbFile.createNewFile();

        Debug.println("Database created");
      }
      return true;
    } catch (Exception e) {
      System.err.println("Error opening database");
      System.err.println(e);
      return false;
    }
  }
 private File createTmpFile(Block b, File f) throws IOException {
   if (f.exists()) {
     throw new IOException(
         "Unexpected problem in creating temporary file for "
             + b
             + ".  File "
             + f
             + " should not be present, but is.");
   }
   // Create the zero-length temp file
   //
   boolean fileCreated = false;
   try {
     fileCreated = f.createNewFile();
   } catch (IOException ioe) {
     throw (IOException) new IOException(DISK_ERROR + f).initCause(ioe);
   }
   if (!fileCreated) {
     throw new IOException(
         "Unexpected problem in creating temporary file for "
             + b
             + ".  File "
             + f
             + " should be creatable, but is already present.");
   }
   return f;
 }
Beispiel #7
0
  // Saves the user info to a file
  public void saveUserInfo(String path) throws IOException {
    // Declare and initialize file object
    File file = new File(path + "\\Personal.txt");

    // Test if the file exists
    if (file.exists()) {
    } else file.createNewFile();

    // Declare and initialize a writer object
    PrintWriter write = new PrintWriter(new FileWriter(file, false));

    // Write information to file
    write.println(first);
    write.println(last);
    write.println(gender);
    write.println(birthDate);
    write.println(address);
    write.println(phoneNumber);
    write.println(province);
    write.println(city);
    write.println(postal);
    write.println(sin);

    write.close();
  } // End of saveUserInfo method
  // Contructor that takes in the usernames of the users
  public ServerFileIO(String username1, String username2) throws IOException {
    // Sets the naming convention for the files
    // The convention is:
    // <Smaller Username><Larger Username>.txt

    user1 = username1;
    user2 = username2;

    if (username1.compareTo(username2) < 0)
      file =
          new File(
              System.getProperty("user.home")
                  + "\\Server Message Files\\"
                  + username1
                  + username2
                  + ".txt");
    else if (username1.compareTo(username2) > 0)
      file =
          new File(
              System.getProperty("user.home")
                  + "\\Server Message Files\\"
                  + username2
                  + username1
                  + ".txt");
    else {
      throw new IllegalArgumentException("Both usernames are the same");
    }

    file.getParentFile().mkdirs();
    file.createNewFile();

    output = new PrintWriter(new FileWriter(file, true));
    input = new Scanner(file);
  }
  void ReceiveFile() throws Exception {
    String fileName;

    fileName = din.readUTF();

    if (fileName != null && !fileName.equals("NOFILE")) {
      System.out.println("Receiving File");
      File f =
          new File(
              System.getProperty("user.home")
                  + "/Desktop"
                  + "/"
                  + fileName.substring(fileName.lastIndexOf("/") + 1));
      System.out.println(f.toString());
      f.createNewFile();
      FileOutputStream fout = new FileOutputStream(f);
      int ch;
      String temp;
      do {
        temp = din.readUTF();
        ch = Integer.parseInt(temp);
        if (ch != -1) {
          fout.write(ch);
        }
      } while (ch != -1);
      System.out.println("Received File : " + fileName);
      fout.close();
    } else {
    }
  }
  public SaikuDatasource addDatasource(SaikuDatasource datasource) {
    try {
      String uri = repoURL.toURI().toString();
      if (uri != null && datasource != null) {
        uri += datasource.getName().replace(" ", "_");
        File dsFile = new File(new URI(uri));
        if (dsFile.exists()) {
          dsFile.delete();
        } else {
          dsFile.createNewFile();
        }
        FileWriter fw = new FileWriter(dsFile);
        Properties props = datasource.getProperties();
        props.store(fw, null);
        fw.close();
        datasources.put(datasource.getName(), datasource);
        return datasource;

      } else {
        throw new SaikuServiceException(
            "Cannot save datasource because uri or datasource is null uri(" + (uri == null) + ")");
      }
    } catch (Exception e) {
      throw new SaikuServiceException("Error saving datasource", e);
    }
  }
Beispiel #11
0
    public static File saveFileAs(JComponent parent) {
      File f = null;
      try {
        JFileChooser jfc = new JFileChooser();

        FileNameExtensionFilter csvfilter = new FileNameExtensionFilter("CSV", "csv");
        jfc.addChoosableFileFilter(csvfilter);

        FileNameExtensionFilter tsvfilter = new FileNameExtensionFilter("TSV", "tsv");
        jfc.addChoosableFileFilter(tsvfilter);

        FileNameExtensionFilter xmlfilter = new FileNameExtensionFilter("XML", "xml");
        jfc.addChoosableFileFilter(xmlfilter);

        FileNameExtensionFilter txtfilter = new FileNameExtensionFilter("Text", "txt");
        jfc.addChoosableFileFilter(txtfilter);

        FileNameExtensionFilter jsonfilter = new FileNameExtensionFilter("JSON", "json");
        jfc.addChoosableFileFilter(jsonfilter);

        jfc.setDialogTitle("VirtualSPARQLer: FileSaver");
        jfc.showSaveDialog(parent);
        f = jfc.getSelectedFile();
        f.createNewFile();
      } catch (IOException ex) {
        mylogger.log(Level.SEVERE, "Error: Can not save file: {0}", ex.getMessage());
      } finally {
        return f;
      }
    }
  // grants a group (players with a specific permission) bonus claim blocks as
  // long as they're still members of the group
  @Override
  synchronized void saveGroupBonusBlocks(String groupName, int currentValue) {
    // write changes to file to ensure they don't get lost
    BufferedWriter outStream = null;
    try {
      // open the group's file
      File groupDataFile = new File(playerDataFolderPath + File.separator + "$" + groupName);
      groupDataFile.createNewFile();
      outStream = new BufferedWriter(new FileWriter(groupDataFile));

      // first line is number of bonus blocks
      outStream.write(String.valueOf(currentValue));
      outStream.newLine();
    }

    // if any problem, log it
    catch (Exception e) {
      GriefPrevention.AddLogEntry(
          "Unexpected exception saving data for group \"" + groupName + "\": " + e.getMessage());
    }

    try {
      // close the file
      if (outStream != null) {
        outStream.close();
      }
    } catch (IOException exception) {
    }
  }
Beispiel #13
0
  public static void write(String path, String content) {
    String s1 = new String();
    try {
      File f = new File(path);
      if (f.exists()) {
        System.out.println("文件存在");
      } else {
        System.out.println("文件不存在,正在创建....");
        if (f.createNewFile()) {
          System.out.println("文件创建成功!");
        } else {
          System.out.println("文件创建失败!");
        }
      }

      s1 = "\n" + content;

      OutputStream outPut = new FileOutputStream(path, true);
      byte[] b = s1.getBytes();
      outPut.write(b, 0, b.length);
      outPut.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 public void save(File target) {
   try {
     target.createNewFile(); // Creates a new file, if one doesn't exist already
     PrintWriter writer = new PrintWriter(target);
     // Prints some game info
     writer.println(sideLength_);
     writer.println(currentPlayer_);
     // Printing the state of the board
     for (int y = 0; y < sideLength_; y++) {
       for (int x = 0; x < sideLength_; x++) {
         writer.print(board_[x][y]);
         if (x != sideLength_ - 1) {
           writer.print(valueSeparator_);
         }
       }
       if (y != sideLength_ - 1) // Not yet the last line
       {
         writer.println();
       }
     }
     writer.close();
   } catch (Exception e) {
     System.out.println(e);
   }
 }
  @Override
  synchronized void incrementNextClaimID() {
    // increment in memory
    this.nextClaimID++;

    BufferedWriter outStream = null;

    try {
      // open the file and write the new value
      File nextClaimIdFile = new File(nextClaimIdFilePath);
      nextClaimIdFile.createNewFile();
      outStream = new BufferedWriter(new FileWriter(nextClaimIdFile));

      outStream.write(String.valueOf(this.nextClaimID));
    }

    // if any problem, log it
    catch (Exception e) {
      GriefPrevention.AddLogEntry("Unexpected exception saving next claim ID: " + e.getMessage());
    }

    // close the file
    try {
      if (outStream != null) outStream.close();
    } catch (IOException exception) {
    }
  }
Beispiel #16
0
 /**
  * automatically generate non-existing help html files for existing commands in the CommandLoader
  *
  * @param cl the CommandLoader where you look for the existing commands
  */
 public void createHelpText(CommandLoader cl) {
   File dir = new File((getClass().getResource("..").getPath()));
   dir = new File(dir, language);
   if (!dir.exists() && !dir.mkdirs()) {
     System.out.println("Failed to create " + dir.getAbsolutePath());
     return;
   }
   for (String mnemo : cl.getMnemoList()) {
     if (!exists(mnemo)) {
       File file = new File(dir, mnemo + ".htm");
       try {
         file.createNewFile();
         BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(file));
         PrintStream ps = new PrintStream(os);
         ps.println("<html>\n<head>\n<title>" + mnemo + "\n</title>\n</head>\n<body>");
         ps.println("Command: " + mnemo.toUpperCase() + "<br>");
         ps.println("arguments: <br>");
         ps.println("effects: <br>");
         ps.println("flags to be set: <br>");
         ps.println("approx. clockcycles: <br>");
         ps.println("misc: <br>");
         ps.println("</body>\n</html>");
         ps.flush();
         ps.close();
       } catch (IOException e) {
         System.out.println("failed to create " + file.getAbsolutePath());
       }
     }
   }
 }
  public void writeToFile() throws DictionaryException {
    try {
      Date date = new Date();
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd.mm.yyy hh:mm");

      String fileName = simpleDateFormat.format(date) + " Dictionary.txt";
      File file = new File(fileName);

      file.createNewFile();

      PrintWriter pout = new PrintWriter(file.getAbsoluteFile());

      try {
        String string;

        for (Map.Entry entry : dictionary.entrySet()) {
          string = "Слово: " + entry.getKey() + "   Документ: " + entry.getValue() + "\n";
          pout.println(string);
          ammautcount += 1;
        }

        pout.print("\n Количество слов словаре:" + ammautcount);
      } finally {
        pout.close();
      }
    } catch (IOException e) {
      throw new DictionaryException(e);
    }
  }
  // saves changes to player data. MUST be called after you're done making
  // changes, otherwise a reload will lose them
  @Override
  public synchronized void savePlayerData(String playerName, PlayerData playerData) {
    // never save data for the "administrative" account. an empty string for
    // claim owner indicates administrative account
    if (playerName.length() == 0) return;

    BufferedWriter outStream = null;
    try {
      // open the player's file
      File playerDataFile =
          new File(playerDataFolderPath + File.separator + playerName.toLowerCase());
      playerDataFile.createNewFile();
      outStream = new BufferedWriter(new FileWriter(playerDataFile));

      // first line is last login timestamp
      if (playerData.lastLogin == null) playerData.lastLogin = new Date();
      DateFormat dateFormat = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss");
      outStream.write(dateFormat.format(playerData.lastLogin));
      outStream.newLine();

      // second line is accrued claim blocks
      outStream.write(String.valueOf(playerData.accruedClaimBlocks));
      outStream.newLine();

      // third line is bonus claim blocks
      outStream.write(String.valueOf(playerData.bonusClaimBlocks));
      outStream.newLine();

      // fourth line is a double-semicolon-delimited list of claims
      /*if (playerData.claims.size() > 0) {
      	outStream.write(this.locationToString(playerData.claims.get(0).getLesserBoundaryCorner()));
      	for (int i = 1; i < playerData.claims.size(); i++) {
      		outStream.write(";;" + this.locationToString(playerData.claims.get(i).getLesserBoundaryCorner()));
      	}
      } */

      // write out wether the player's inventory needs to be cleared on join.
      outStream.newLine();
      outStream.write(String.valueOf(playerData.ClearInventoryOnJoin));
      outStream.newLine();
    }

    // if any problem, log it
    catch (Exception e) {
      GriefPrevention.AddLogEntry(
          "GriefPrevention: Unexpected exception saving data for player \""
              + playerName
              + "\": "
              + e.getMessage());
    }

    try {
      // close the file
      if (outStream != null) {
        outStream.close();
      }
    } catch (IOException exception) {
    }
  }
 public Template(File file, boolean cr) throws Exception {
   if (cr) file.createNewFile();
   if (file.length() > maxF) tools.util.LogMgr.red(file.length() + " Large Size Template " + file);
   String templ = new String(SharedMethods.getBytesFromFile(file));
   m_template = new StringBuffer(templ);
   m_template2 = new StringBuffer(templ);
   m_file = file.toString();
 }
Beispiel #20
0
 public static boolean copyDir(String fromDir, String toDir) throws IOException {
   File contentFile = new File(toDir + ".INIT");
   if (!contentFile.exists()) {
     IO.copyDirTree(fromDir, toDir);
     contentFile.createNewFile();
     return true;
   }
   return false;
 }
Beispiel #21
0
  public static void addToResultsFile(
      String executingDatabaseName,
      long runTime,
      long rowsLoaded,
      long rowsLoadedPerSecond,
      File resultsFile) {

    boolean resultsFileCreated = false;

    try {
      if (!resultsFile.exists()) {

        resultsFileCreated = resultsFile.createNewFile();
      }

      OutputStream resultsFileStream = new FileOutputStream(resultsFile, true);

      if (resultsFileCreated) {
        // Write header lines.

        String header =
            "timeOfTest, runTime, databaseBeingTested, rowsLoaded, rowsLoadedPerSecond, hotStart, config, replicas"
                + "\n";

        resultsFileStream.write(header.getBytes());
      }

      String results =
          startDate.getTime()
              + ", "
              + runTime
              + ", "
              + executingDatabaseName
              + ", "
              + rowsLoaded
              + ", "
              + rowsLoadedPerSecond
              + ", "
              + hotStart
              + ", "
              + configInfo
              + ", "
              + numberOfReplicas
              + "\n";
      resultsFileStream.write(results.getBytes());

      resultsFileStream.flush();

      resultsFileStream.close();

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Beispiel #22
0
  void doExeCommand() {
    JViewport viewport = scrollPane.getViewport();
    String strContent = new String();
    PSlider slider;
    int i;
    File fp = new File(dataFile);

    RandomAccessFile access = null;
    Runtime program = Runtime.getRuntime();
    String cmdTrigger = "trigger";

    boolean delete = fp.delete();

    try {
      fp.createNewFile();
    } catch (IOException ie) {
      System.err.println("Couldn't create the new file " + ie);
      // System.exit(-1);;
    }

    try {
      access = new RandomAccessFile(fp, "rw");
    } catch (IOException ie) {
      System.err.println("Error in accessing the file " + ie);
      // System.exit(-1);;
    }

    for (i = 0; i < COMPONENTS; i++) {
      slider = (PSlider) vSlider.elementAt(i);
      /* Modified on March 20th to satisfy advisors' new request */
      if (slider.isString == true) strContent = strContent + slider.getRealStringValue() + " ";
      else strContent = strContent + slider.getValue() + " ";
    }

    // Get value of the radio button group
    if (firstBox.isSelected() == true) strContent = strContent + "1";
    else strContent = strContent + "0";

    try {
      access.writeBytes(strContent);
      access.close();
    } catch (IOException ie) {
      System.err.println("Error in writing to file " + ie);
      // System.exit(-1);;
    }
    // Trigger the OpenGL program to update with new values
    try {
      Process pid = program.exec(cmdTrigger);
    } catch (IOException ie) {
      System.err.println("Couldn't run " + ie);
      // System.exit(-1);;
    }
    doSourceFileUpdate();
  }
Beispiel #23
0
 public WriteToFile(String file) {
   try {
     fc = new File(file);
     if (!fc.exists()) {
       fc.createNewFile();
     }
     fw = new FileWriter(fc, true);
     bw = new BufferedWriter(fw);
     pw = new PrintWriter(bw);
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Beispiel #24
0
 /**
  * debug
  *
  * @param filename look for this file
  * @throws java.io.IOException if read error
  */
 static void make(String filename) throws IOException {
   File want = DiskCache.getCacheFile(filename);
   System.out.println("make=" + want.getPath() + "; exists = " + want.exists());
   if (!want.exists()) want.createNewFile();
   System.out.println(
       " canRead= "
           + want.canRead()
           + " canWrite = "
           + want.canWrite()
           + " lastMod = "
           + new Date(want.lastModified()));
   System.out.println(" original=" + filename);
 }
  private File createDesktopAgentPropertiesFile(String propertiesFileName) {
    File tempFile = null;

    tempFile = new File(propertiesFileName);

    try {
      if (tempFile.createNewFile()) {}

    } catch (IOException ioe) {
      ioe.printStackTrace();
    }

    return tempFile;
  }
Beispiel #26
0
 public static File saveFile(JComponent parent) {
   File f = null;
   try {
     JFileChooser jfc = new JFileChooser();
     jfc.setDialogTitle("VirtualSPARQLer: FileSaver");
     jfc.showSaveDialog(parent);
     f = jfc.getSelectedFile();
     f.createNewFile();
   } catch (IOException ex) {
     mylogger.log(Level.SEVERE, "Error: Can not save file: {0}", ex.getMessage());
   } finally {
     return f;
   }
 }
Beispiel #27
0
 @Override
 public int commit() {
   String key;
   String value;
   rm();
   try {
     for (Map.Entry<String, String> i : map.entrySet()) {
       key = i.getKey();
       value = i.getValue();
       Integer ndirectory = Math.abs(key.getBytes("UTF-8")[0] % N);
       Integer nfile = Math.abs((key.getBytes("UTF-8")[0] / N) % N);
       String pathToDir = path + File.separator + ndirectory.toString() + ".dir";
       File file = new File(pathToDir);
       if (!file.exists()) {
         file.mkdir();
       }
       String pathToFile =
           path
               + File.separator
               + ndirectory.toString()
               + ".dir"
               + File.separator
               + nfile.toString()
               + ".dat";
       file = new File(pathToFile);
       if (!file.exists()) {
         file.createNewFile();
       }
       DataOutputStream outStream = new DataOutputStream(new FileOutputStream(pathToFile, true));
       byte[] byteWord = key.getBytes("UTF-8");
       outStream.writeInt(byteWord.length);
       outStream.write(byteWord);
       outStream.flush();
       byteWord = value.getBytes("UTF-8");
       outStream.writeInt(byteWord.length);
       outStream.write(byteWord);
       outStream.flush();
       outStream.close();
     }
   } catch (IOException e) {
     System.err.println(e.getMessage());
     System.exit(-1);
   }
   TableState ts = new TableState(map, unsavedChanges, numberOfElements);
   tableStates.put(++numberOfState, ts);
   int n = unsavedChanges;
   unsavedChanges = 0;
   return n;
 }
    @Override
    public void run() {
      // long startTime = System.nanoTime();
      synchronized (configFile) {
        if (pendingDiskWrites.get() > 1) {
          // Writes can be skipped, because they are stored in a queue (in the executor).
          // Only the last is actually written.
          pendingDiskWrites.decrementAndGet();
          // LOGGER.log(Level.INFO, configFile + " skipped writing in " + (System.nanoTime() -
          // startTime) + " nsec.");
          return;
        }
        try {
          Files.createParentDirs(configFile);

          if (!configFile.exists()) {
            try {
              LOGGER.log(Level.INFO, tl("creatingEmptyConfig", configFile.toString()));
              if (!configFile.createNewFile()) {
                LOGGER.log(Level.SEVERE, tl("failedToCreateConfig", configFile.toString()));
                return;
              }
            } catch (IOException ex) {
              LOGGER.log(Level.SEVERE, tl("failedToCreateConfig", configFile.toString()), ex);
              return;
            }
          }

          final FileOutputStream fos = new FileOutputStream(configFile);
          try {
            final OutputStreamWriter writer = new OutputStreamWriter(fos, UTF8);

            try {
              writer.write(data);
            } finally {
              writer.close();
            }
          } finally {
            fos.close();
          }
        } catch (IOException e) {
          LOGGER.log(Level.SEVERE, e.getMessage(), e);
        } finally {
          // LOGGER.log(Level.INFO, configFile + " written to disk in " + (System.nanoTime() -
          // startTime) + " nsec.");
          pendingDiskWrites.decrementAndGet();
        }
      }
    }
 private File createFile(String testClass, String testName) {
   File file = new File(String.format(FILE_NAME_FORMAT, testClass, testName));
   int i = 1;
   while (file.exists()) {
     file = new File(String.format(FILE_NAME_FORMAT_IF_EXISTS, testClass, testName, i++));
   }
   boolean success;
   try {
     success = file.createNewFile();
   } catch (IOException e) {
     e.printStackTrace();
     success = false;
   }
   return success ? file : null;
 }
Beispiel #30
0
  public void save(File file) {
    if (!file.exists()) {
      try {
        file.createNewFile();
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }

    try (ObjectOutputStream out =
        new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(file)))) {
      out.writeObject(this);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }