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
|
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
* @return
*/
public static int parseInt( String value, int defaultValue )
{
try {
return Integer.parseInt( 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;
}
}
|
