1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
package org.openslx.util;
import java.util.regex.Pattern;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Util
{
private static Logger log = LogManager.getLogger( Util.class );
/**
* Check if the given object is null, abort program if true. An optional
* message to be printed can be passed. A stack trace will be printed, too.
* Finally the application terminates with exit code 2.
*
* This comes in handy if something must not be null, and you want user
* friendly output. A perfect example would be reading settings from a
* config file. You can use this on mandatory fields.
*
* @param something the object to compare to null
* @param message the message to be printed if something is null
*/
public static void notNullFatal( Object something, String message )
{
if ( something == null ) {
if ( message != null )
log.fatal( "[NOTNULL] " + message );
log.warn( "Fatal null pointer exception", new NullPointerException() );
System.exit( 2 );
}
}
private static Pattern nonprintableExp = Pattern.compile( "[\\p{C}\\p{Zl}\\p{Zp}]" );
private static Pattern nonSpaceExp = Pattern.compile( "[^\\p{C}\\p{Z}]" );
/**
* Whether the given string contains only printable characters.
*/
public static boolean isPrintable( String string )
{
return !nonprintableExp.matcher( string ).find();
}
/**
* Whether given string is null, empty, or only matches space-like
* characters.
*/
public static boolean isEmptyString( String string )
{
return string == null || !nonSpaceExp.matcher( string ).find();
}
/**
* Check if given string is null or empty and abort program if so.
*
* @param something String to check
* @param message Error message to display on abort
*/
public static void notNullOrEmptyFatal( String something, String message )
{
if ( isEmptyString( something ) ) {
if ( message != null )
log.fatal( "[NOTNULL] " + message );
log.warn( "Fatal null pointer or empty exception", new NullPointerException() );
System.exit( 2 );
}
}
/**
* Parse the given String as a base10 integer.
* If the string does not represent a valid integer, return the given
* default value.
*
* @param value string representation to parse to an int
* @param defaultValue fallback value if given string can't be parsed
*/
public static int parseInt( String value, int defaultValue )
{
try {
return Integer.parseInt( value );
} catch ( Exception e ) {
return defaultValue;
}
}
/**
* Parse the given String as a base10 long.
* If the string does not represent a valid long, return the given
* default value.
*
* @param value string representation to parse to a long
* @param defaultValue fallback value if given string can't be parsed
*/
public static long parseLong( String value, long defaultValue )
{
try {
return Long.parseLong( value );
} catch ( Exception e ) {
return defaultValue;
}
}
public static void safeClose( AutoCloseable... closeable )
{
for ( AutoCloseable c : closeable ) {
if ( c == null )
continue;
try {
c.close();
} catch ( Throwable t ) {
}
}
}
public static boolean sleep( int millis )
{
try {
Thread.sleep( millis );
return true;
} catch ( InterruptedException e ) {
Thread.currentThread().interrupt();
return false;
}
}
public static boolean joinThread( Thread t )
{
try {
t.join();
return true;
} catch ( InterruptedException e ) {
return false;
}
}
/**
* Number of seconds elapsed since 1970-01-01 UTC.
*/
public static long unixTime()
{
return System.currentTimeMillis() / 1000;
}
/**
* Monotonic tick count in milliseconds, not bound to RTC.
*/
public static long tickCount()
{
return System.nanoTime() / 1000;
}
private static final String[] UNITS = new String[] { "B", "KB", "MB", "GB", "TB", "PB", "???" };
public static String formatBytes( double val )
{
int unit = 0;
while ( val > 1024 ) {
val /= 1024;
unit++;
if (unit >= UNITS.length)
break;
}
return String.format( "%.1f %s", val, UNITS[unit] );
}
}
|
