private List<T> implementers = null;
// 'ServiceLoader' that is used to discover and create the services
- private ServiceLoader<T> serviceLoader = null; //ServiceLoader.load(T.class);
+ private ServiceLoader<T> serviceLoader = null;
+
+ // use this to ensure that we only use one unique instance of each class
+ @SuppressWarnings("rawtypes")
+ private static HashMap<Class,OrderedService> classToSingleton =
+ new HashMap<>();
/**
* Constructor - create the 'ServiceLoader' instance
rval = o1.getClass().getName().compareTo
(o2.getClass().getName());
}
- return(rval);
+ return rval;
}
});
return implementers;
}
- // use this to ensure that we only use one unique instance of each class
- @SuppressWarnings("rawtypes")
- static private HashMap<Class,OrderedService> classToSingleton =
- new HashMap<>();
-
/**
* If a service implements multiple APIs managed by 'ServiceLoader', a
* separate instance is created for each API. This method ensures that
* the object of this class that was initially created is returned
* instead.
*/
- static private synchronized OrderedService
+ private static synchronized OrderedService
getSingleton(OrderedService service)
{
// see if we already have an instance of this class
import java.util.Timer;
import java.util.TimerTask;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
* This class provides utilities to read properties from a properties
* file, and optionally get notifications of future changes
*/
public class PropertyUtil
{
+
+ // timer thread used for polling for property file changes
+ private static Timer timer = null;
+
+ // this table maps canonical file into a 'ListenerRegistration' instance
+ private static HashMap<File, ListenerRegistration> registrations =
+ new HashMap<>();
+
+ private static final Logger logger = LoggerFactory.getLogger(PropertyUtil.class.getName());
+
/**
* Read in a properties file
* @param file the properties file
* does not exist or can't be opened, and 'IOException' if there is
* a problem loading the properties file.
*/
- static public Properties getProperties(File file) throws IOException
+ public static Properties getProperties(File file) throws IOException
{
// create an InputStream (may throw a FileNotFoundException)
FileInputStream fis = new FileInputStream(file);
* does not exist or can't be opened, and 'IOException' if there is
* a problem loading the properties file.
*/
- static public Properties getProperties(String fileName) throws IOException
+ public static Properties getProperties(String fileName) throws IOException
{
return getProperties(new File(fileName));
}
/* ============================================================ */
- // timer thread used for polling for property file changes
- private static Timer timer = null;
-
/**
* This is the callback interface, used for sending notifications of
* changes in the properties file.
void propertiesChanged(Properties properties, Set<String> changedKeys);
}
- // this table maps canonical file into a 'ListenerRegistration' instance
- static private HashMap<File, ListenerRegistration> registrations =
- new HashMap<>();
-
/**
* This is an internal class - one instance of this exists for each
* property file that is being monitored. Note that multiple listeners
}
catch (Exception e)
{
- System.err.println(e);
+ logger.warn("Polling for property changes", e);
}
}
};
* does not exist or can't be opened, and 'IOException' if there is
* a problem loading the properties file.
*/
- static public Properties getProperties(File file, Listener listener)
+ public static Properties getProperties(File file, Listener listener)
throws IOException
{
+ File propFile = file;
if (listener == null)
{
// no listener specified -- just fetch the properties
- return getProperties(file);
+ return getProperties(propFile);
}
// Convert the file to a canonical form in order to avoid the situation
// where different names refer to the same file.
- file = file.getCanonicalFile();
+ propFile = propFile.getCanonicalFile();
// See if there is an existing registration. The 'synchronized' block
// is needed to handle the case where a new listener is added at about
// the same time that another one is being removed.
synchronized(registrations)
{
- ListenerRegistration reg = registrations.get(file);
+ ListenerRegistration reg = registrations.get(propFile);
if (reg == null)
{
// a new registration is needed
- reg = new ListenerRegistration(file);
+ reg = new ListenerRegistration(propFile);
}
return reg.addListener(listener);
}
* does not exist or can't be opened, and 'IOException' if there is
* a problem loading the properties file.
*/
- static public Properties getProperties(String fileName, Listener listener)
+ public static Properties getProperties(String fileName, Listener listener)
throws IOException
{
return getProperties(new File(fileName), listener);
* @param notify if not null, this is a callback interface that was used for
* notifications of changes
*/
- static public void stopListening(File file, Listener listener)
+ public static void stopListening(File file, Listener listener)
{
if (listener != null)
{
* @param notify if not null, this is a callback interface that was used for
* notifications of changes
*/
- static public void stopListening(String fileName, Listener listener)
+ public static void stopListening(String fileName, Listener listener)
{
stopListening(new File(fileName), listener);
}
Code Review / policy / drools-pdp.git / commitdiff