API tools faq
paste
Fabian42

Util 2019-07-27

Fabian42
Jul 27th, 2019
488
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 25.05 KB | None | 0 0
raw download clone embed print report
  1. package Sandbox;
  2. import java.io.*;
  3. import java.lang.reflect.*;
  4. import java.nio.file.*;
  5. import java.util.*;
  6.  
  7. /** Contains various commonly used procedures that should be part of the JDK, but aren't:<br>
  8.  * - better and shorter print methods<br>
  9.  * - safely write a list or array to a file and read a list from a file<br>
  10.  * Most often used outside of this class:<br>
  11.  * - <code>print(Object)</code><br>
  12.  * - <code>fromFile(String)</code><br>
  13.  * - <code>toFile(String,List<Object>)</code><br>
  14.  * - <code>toFile(String,Object)</code><br>
  15.  * The complex methods, most likely to be the cause of bugs:<br>
  16.  * - <code>stringify(Object)</code><br>
  17.  * - <code>prepareFile(String,boolean)</code> */
  18. public class Util{
  19.     /** If true, errors will be printed to console if things go wrong. */
  20.     public static boolean output=true;
  21.     public static boolean stacks=true;
  22.  
  23.     /** Converts an object (usually a list, map, etc.) into a string.<br>
  24.      * Arrays become similar to <code>[1,2,3]</code>, lists to <code>{1,2,3}</code> and maps to <code>{1=A,2=B,3=C}</code>.<br>
  25.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be converted to <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  26.     public static String stringify(Object arg){
  27.         if(arg.getClass().isArray()){
  28.             StringBuilder builder=new StringBuilder("[");
  29.             int length=Array.getLength(arg);
  30.             for(int i=0;i<length;i++){
  31.                 // similar to "builder+=arg[i]"
  32.                 builder.append(stringify(Array.get(arg,i)));
  33.                 // add a comma between all elements, but not after the last
  34.                 if(i<length-1) builder.append(",");
  35.             }
  36.             builder.append("]");
  37.             return builder.toString();
  38.             // a map is just a set (collection) of Map.Entry
  39.         }else if(arg instanceof Map) return stringify(((Map)arg).entrySet());
  40.         else if(arg instanceof Collection){
  41.             StringBuilder builder=new StringBuilder("{");
  42.             boolean first=true;
  43.             for(Object element:(Collection)arg){
  44.                 // add a comma before all elements that are not the first=add a comma between all elements, but not before the first or after the last
  45.                 if(!first) builder.append(",");
  46.                 first=false;
  47.                 builder.append(stringify(element));
  48.             }
  49.             builder.append("}");
  50.             return builder.toString(); // not recursion
  51.         }else if(arg instanceof Map.Entry) return stringify(((Map.Entry)arg).getKey())+"="+stringify(((Map.Entry)arg).getValue());
  52.         else return arg.toString();
  53.     }
  54.  
  55.     /** Prints a single object to the console without appending a newline. Use <code>print</code> for also appending a newline.<br>
  56.      * Similar to <code>System.out.print</code>, but better.<br>
  57.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  58.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  59.     public static void pri(Object arg){
  60.         if(arg instanceof String&&((String)arg).startsWith("ERROR")) System.err.print(stringify(arg));
  61.         else System.out.print(stringify(arg));
  62.     }
  63.  
  64.     public static void printArray(Object[] array){
  65.         for(Object element:array){
  66.             print(element);
  67.         }
  68.     }
  69.  
  70.     /** Prints a newline. Shortcut for <code>System.out.println()</code>. */
  71.     public static void print(){
  72.         System.out.println();
  73.     }
  74.  
  75.     /** Prints one object to the console and appends a newline. Use <code>pri</code> for printing without appending a newline.<br>
  76.      * Similar to <code>System.out.println</code>, but better.<br>
  77.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  78.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  79.     public static void print(Object arg0){
  80.         pri(arg0);
  81.         System.out.println();
  82.     }
  83.  
  84.     /** Prints two objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  85.      * Similar to <code>System.out.println</code>, but better.<br>
  86.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  87.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  88.     public static void print(Object arg0,Object arg1){
  89.         pri(arg0);
  90.         System.out.println();
  91.         pri(arg1);
  92.         System.out.println();
  93.     }
  94.  
  95.     /** Prints three objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  96.      * Similar to <code>System.out.println</code>, but better.<br>
  97.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  98.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  99.     public static void print(Object arg0,Object arg1,Object arg2){
  100.         pri(arg0);
  101.         System.out.println();
  102.         pri(arg1);
  103.         System.out.println();
  104.         pri(arg2);
  105.         System.out.println();
  106.     }
  107.  
  108.     /** Prints four objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  109.      * Similar to <code>System.out.println</code>, but better.<br>
  110.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  111.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  112.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3){
  113.         pri(arg0);
  114.         System.out.println();
  115.         pri(arg1);
  116.         System.out.println();
  117.         pri(arg2);
  118.         System.out.println();
  119.         pri(arg3);
  120.         System.out.println();
  121.     }
  122.  
  123.     /** Prints five objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  124.      * Similar to <code>System.out.println</code>, but better.<br>
  125.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  126.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  127.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4){
  128.         pri(arg0);
  129.         System.out.println();
  130.         pri(arg1);
  131.         System.out.println();
  132.         pri(arg2);
  133.         System.out.println();
  134.         pri(arg3);
  135.         System.out.println();
  136.         pri(arg4);
  137.         System.out.println();
  138.     }
  139.  
  140.     /** Prints six objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  141.      * Similar to <code>System.out.println</code>, but better.<br>
  142.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  143.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  144.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5){
  145.         pri(arg0);
  146.         System.out.println();
  147.         pri(arg1);
  148.         System.out.println();
  149.         pri(arg2);
  150.         System.out.println();
  151.         pri(arg3);
  152.         System.out.println();
  153.         pri(arg4);
  154.         System.out.println();
  155.         pri(arg5);
  156.         System.out.println();
  157.     }
  158.  
  159.     /** Prints seven objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  160.      * Similar to <code>System.out.println</code>, but better.<br>
  161.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  162.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  163.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6){
  164.         pri(arg0);
  165.         System.out.println();
  166.         pri(arg1);
  167.         System.out.println();
  168.         pri(arg2);
  169.         System.out.println();
  170.         pri(arg3);
  171.         System.out.println();
  172.         pri(arg4);
  173.         System.out.println();
  174.         pri(arg5);
  175.         System.out.println();
  176.         pri(arg6);
  177.         System.out.println();
  178.     }
  179.  
  180.     /** Prints eight objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  181.      * Similar to <code>System.out.println</code>, but better.<br>
  182.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  183.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  184.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7){
  185.         pri(arg0);
  186.         System.out.println();
  187.         pri(arg1);
  188.         System.out.println();
  189.         pri(arg2);
  190.         System.out.println();
  191.         pri(arg3);
  192.         System.out.println();
  193.         pri(arg4);
  194.         System.out.println();
  195.         pri(arg5);
  196.         System.out.println();
  197.         pri(arg6);
  198.         System.out.println();
  199.         pri(arg7);
  200.         System.out.println();
  201.     }
  202.  
  203.     /** Prints nine objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  204.      * Similar to <code>System.out.println</code>, but better.<br>
  205.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  206.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  207.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8){
  208.         pri(arg0);
  209.         System.out.println();
  210.         pri(arg1);
  211.         System.out.println();
  212.         pri(arg2);
  213.         System.out.println();
  214.         pri(arg3);
  215.         System.out.println();
  216.         pri(arg4);
  217.         System.out.println();
  218.         pri(arg5);
  219.         System.out.println();
  220.         pri(arg6);
  221.         System.out.println();
  222.         pri(arg7);
  223.         System.out.println();
  224.         pri(arg8);
  225.         System.out.println();
  226.     }
  227.  
  228.     /** Prints ten objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  229.      * Similar to <code>System.out.println</code>, but better.<br>
  230.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  231.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  232.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9){
  233.         pri(arg0);
  234.         System.out.println();
  235.         pri(arg1);
  236.         System.out.println();
  237.         pri(arg2);
  238.         System.out.println();
  239.         pri(arg3);
  240.         System.out.println();
  241.         pri(arg4);
  242.         System.out.println();
  243.         pri(arg5);
  244.         System.out.println();
  245.         pri(arg6);
  246.         System.out.println();
  247.         pri(arg7);
  248.         System.out.println();
  249.         pri(arg8);
  250.         System.out.println();
  251.         pri(arg9);
  252.         System.out.println();
  253.     }
  254.  
  255.     /** Prints eleven objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  256.      * Similar to <code>System.out.println</code>, but better.<br>
  257.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  258.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  259.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9,Object arg10){
  260.         pri(arg0);
  261.         System.out.println();
  262.         pri(arg1);
  263.         System.out.println();
  264.         pri(arg2);
  265.         System.out.println();
  266.         pri(arg3);
  267.         System.out.println();
  268.         pri(arg4);
  269.         System.out.println();
  270.         pri(arg5);
  271.         System.out.println();
  272.         pri(arg6);
  273.         System.out.println();
  274.         pri(arg7);
  275.         System.out.println();
  276.         pri(arg8);
  277.         System.out.println();
  278.         pri(arg9);
  279.         System.out.println();
  280.         pri(arg10);
  281.         System.out.println();
  282.     }
  283.  
  284.     /** Prints twelve objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  285.      * Similar to <code>System.out.println</code>, but better.<br>
  286.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  287.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  288.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9,Object arg10,Object arg11){
  289.         pri(arg0);
  290.         System.out.println();
  291.         pri(arg1);
  292.         System.out.println();
  293.         pri(arg2);
  294.         System.out.println();
  295.         pri(arg3);
  296.         System.out.println();
  297.         pri(arg4);
  298.         System.out.println();
  299.         pri(arg5);
  300.         System.out.println();
  301.         pri(arg6);
  302.         System.out.println();
  303.         pri(arg7);
  304.         System.out.println();
  305.         pri(arg8);
  306.         System.out.println();
  307.         pri(arg9);
  308.         System.out.println();
  309.         pri(arg10);
  310.         System.out.println();
  311.         pri(arg11);
  312.         System.out.println();
  313.     }
  314.  
  315.     /** Prints thirteen objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  316.      * Similar to <code>System.out.println</code>, but better.<br>
  317.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  318.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  319.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9,Object arg10,Object arg11,Object arg12){
  320.         pri(arg0);
  321.         System.out.println();
  322.         pri(arg1);
  323.         System.out.println();
  324.         pri(arg2);
  325.         System.out.println();
  326.         pri(arg3);
  327.         System.out.println();
  328.         pri(arg4);
  329.         System.out.println();
  330.         pri(arg5);
  331.         System.out.println();
  332.         pri(arg6);
  333.         System.out.println();
  334.         pri(arg7);
  335.         System.out.println();
  336.         pri(arg8);
  337.         System.out.println();
  338.         pri(arg9);
  339.         System.out.println();
  340.         pri(arg10);
  341.         System.out.println();
  342.         pri(arg11);
  343.         System.out.println();
  344.         pri(arg12);
  345.         System.out.println();
  346.     }
  347.  
  348.     /** Prints fourteen objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  349.      * Similar to <code>System.out.println</code>, but better.<br>
  350.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  351.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  352.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9,Object arg10,Object arg11,Object arg12,Object arg13){
  353.         pri(arg0);
  354.         System.out.println();
  355.         pri(arg1);
  356.         System.out.println();
  357.         pri(arg2);
  358.         System.out.println();
  359.         pri(arg3);
  360.         System.out.println();
  361.         pri(arg4);
  362.         System.out.println();
  363.         pri(arg5);
  364.         System.out.println();
  365.         pri(arg6);
  366.         System.out.println();
  367.         pri(arg7);
  368.         System.out.println();
  369.         pri(arg8);
  370.         System.out.println();
  371.         pri(arg9);
  372.         System.out.println();
  373.         pri(arg10);
  374.         System.out.println();
  375.         pri(arg11);
  376.         System.out.println();
  377.         pri(arg12);
  378.         System.out.println();
  379.         pri(arg13);
  380.         System.out.println();
  381.     }
  382.  
  383.     /** Prints fifteen objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  384.      * Similar to <code>System.out.println</code>, but better.<br>
  385.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  386.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  387.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9,Object arg10,Object arg11,Object arg12,Object arg13,Object arg14){
  388.         pri(arg0);
  389.         System.out.println();
  390.         pri(arg1);
  391.         System.out.println();
  392.         pri(arg2);
  393.         System.out.println();
  394.         pri(arg3);
  395.         System.out.println();
  396.         pri(arg4);
  397.         System.out.println();
  398.         pri(arg5);
  399.         System.out.println();
  400.         pri(arg6);
  401.         System.out.println();
  402.         pri(arg7);
  403.         System.out.println();
  404.         pri(arg8);
  405.         System.out.println();
  406.         pri(arg9);
  407.         System.out.println();
  408.         pri(arg10);
  409.         System.out.println();
  410.         pri(arg11);
  411.         System.out.println();
  412.         pri(arg12);
  413.         System.out.println();
  414.         pri(arg13);
  415.         System.out.println();
  416.         pri(arg14);
  417.         System.out.println();
  418.     }
  419.  
  420.     /** Prints sixteen objects to the console and appends a newline after each. Use <code>pri</code> for printing one object without appending a newline.<br>
  421.      * Use <code>print</code> multiple times for more objects. Varargs would interfere with arrays of objects (not of primitive types) and adding methods with up to 255 arguments would lag autocomplete too much in some IDEs.<br>
  422.      * Similar to <code>System.out.println</code>, but better.<br>
  423.      * Prints arrays like <code>[1,2,3]</code>, lists like <code>{1,2,3}</code> and maps like <code>{1=A,2=B,3=C}</code>.<br>
  424.      * Nested arrays, lists and maps also work, for example a list of arrays of arrays would be displayed as <code>{[[1,2],[3,4]],[[5,6],[7,8]]}</code>. */
  425.     public static void print(Object arg0,Object arg1,Object arg2,Object arg3,Object arg4,Object arg5,Object arg6,Object arg7,Object arg8,Object arg9,Object arg10,Object arg11,Object arg12,Object arg13,Object arg14,Object arg15){
  426.         pri(arg0);
  427.         System.out.println();
  428.         pri(arg1);
  429.         System.out.println();
  430.         pri(arg2);
  431.         System.out.println();
  432.         pri(arg3);
  433.         System.out.println();
  434.         pri(arg4);
  435.         System.out.println();
  436.         pri(arg5);
  437.         System.out.println();
  438.         pri(arg6);
  439.         System.out.println();
  440.         pri(arg7);
  441.         System.out.println();
  442.         pri(arg8);
  443.         System.out.println();
  444.         pri(arg9);
  445.         System.out.println();
  446.         pri(arg10);
  447.         System.out.println();
  448.         pri(arg11);
  449.         System.out.println();
  450.         pri(arg12);
  451.         System.out.println();
  452.         pri(arg13);
  453.         System.out.println();
  454.         pri(arg14);
  455.         System.out.println();
  456.         pri(arg15);
  457.         System.out.println();
  458.     }
  459.  
  460.     /** Reads the lines of a file at location <code>path</code> into a list of strings. */
  461.     public static List<String> fromFile(String path){
  462.         try{
  463.             return Files.readAllLines(Paths.get(path));
  464.         }catch(IOException e){
  465.             if(output){
  466.                 print("ERROR: File \""+path+"\" does not exist.");
  467.                 if(stacks) e.printStackTrace();
  468.             }
  469.             return null;
  470.         }
  471.     }
  472.  
  473.     /** Empties the file at <code>path</code> and writes all elements of <code>lines</code> into it. Creates the file if it doesn't exist already.<br>
  474.      * Returns <code>true</code> if writing was successful, else <code>false</code> */
  475.     public static boolean toFile(String path,List lines){
  476.         return toFile(path,false,lines);
  477.     }
  478.  
  479.     /** Writes all elements of <code>lines</code> into a file at location <code>path</code>. Creates the file if it doesn't exist already. Empties the file first if <code>append</code> is <code>false</code>.<br>
  480.      * Returns <code>true</code> if writing was successful, else <code>false</code> */
  481.     public static boolean toFile(String path,boolean append,List<Object> lines){
  482.         try(BufferedWriter writer=prepareFile(path,append)){
  483.             // abort if prepareFile encountered an error
  484.             if(writer==null) return false;
  485.             for(int index=0;index<lines.size();index++){
  486.                 writer.write(stringify(lines.get(index)));
  487.                 if(index!=lines.size()-1) writer.newLine();
  488.             }
  489.         }catch(IOException e){
  490.             if(output){
  491.                 print("ERROR: File \""+path+"\" is write-only.");
  492.                 if(stacks) e.printStackTrace();
  493.             }
  494.             return false;
  495.         }
  496.         return true;
  497.     }
  498.  
  499.     /** Empties the file at <code>path</code> and writes all elements of <code>lines</code> into it. Creates the file if it doesn't exist already.<br>
  500.      * Returns <code>true</code> if writing was successful, else <code>false</code> */
  501.     public static boolean writeFile(String path,Object line){
  502.         return writeFile(path,true,stringify(line));
  503.     }
  504.  
  505.     /** Writes all elements of <code>lines</code> into a file at location <code>path</code>. Creates the file if it doesn't exist already. Empties the file first if <code>append</code> is <code>false</code>.<br>
  506.      * Returns <code>true</code> if writing was successful, else <code>false</code> */
  507.     public static boolean writeFile(String path,boolean append,Object line){
  508.         try(BufferedWriter writer=prepareFile(path,append)){
  509.             // abort if prepareFile encountered an error
  510.             if(writer==null) return false;
  511.             writer.write(stringify(line));
  512.         }catch(IOException e){
  513.             if(output){
  514.                 print("ERROR: File \""+path+"\" is write-only.");
  515.                 if(stacks) e.printStackTrace();
  516.             }
  517.             return false;
  518.         }
  519.         return true;
  520.     }
  521.  
  522.     /** Gets a BufferedReader for writing to a file at location <code>path</code> and prepares the file. Mainly used in <code>toFile</code>. */
  523.     public static BufferedWriter prepareFile(String path,boolean append){
  524.         File file=new File(path);
  525.         File folder=file.getParentFile();
  526.         // create folder, if it doesn't exit
  527.         if(!folder.exists()&&!folder.mkdirs()){
  528.             print("ERROR: Could not create parent directory of "+path+".");
  529.             return null;
  530.         }
  531.         try{
  532.             // create a new file or use the existing one
  533.             file.createNewFile();
  534.         }catch(IOException e){
  535.             if(output){
  536.                 print("ERROR: File \""+path+"\" can't be created.");
  537.                 if(stacks) e.printStackTrace();
  538.             }
  539.             return null;
  540.         }
  541.         try{
  542.             BufferedWriter writer=new BufferedWriter(new FileWriter(path,append));
  543.             // if new text should be appended after existing text, write a newline
  544.             if(append&&file.length()!=0) writer.newLine();
  545.             return writer;
  546.         }catch(IOException e){
  547.             if(output){
  548.                 print("ERROR: File \""+path+"\" is write-only.");
  549.                 if(stacks) e.printStackTrace();
  550.             }
  551.             return null;
  552.         }
  553.     }
  554. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!